{"expr":"Composite(AA.AuN=='malte appeltauer')","entities":[{"logprob":-18.891,"Id":2144114063,"Ty":"0","Ti":"a comparison of context oriented programming languages","Pt":"0","L":"en","Y":2009,"D":"2009-07-07","CC":96,"ECC":149,"RId":[2138363365,2143238865,2075642720,2150275961,1992443356,2089889705,2154597770,2115607078,2087175184,1501829296,1556513858,2097664691,1597389001,2014881790,2115899208,2294229253],"W":["comparison","context","languages","oriented","programming"],"AA":[{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":135591984,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":1},{"DAuN":"Robert Hirschfeld","AuN":"robert hirschfeld","AuId":2154319088,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":2},{"DAuN":"Michael Haupt","AuN":"michael haupt","AuId":2146662369,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":3},{"DAuN":"Jens Lincke","AuN":"jens lincke","AuId":2055148755,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":4},{"DAuN":"Michael Perscheid","AuN":"michael perscheid","AuId":698431335,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":5}],"F":[{"DFN":"Very high-level programming language","FN":"very high level programming language","FId":169796678},{"DFN":"Third-generation programming language","FN":"third generation programming language","FId":206146517},{"DFN":"Second-generation programming language","FN":"second generation programming language","FId":11164408},{"DFN":"Programming language theory","FN":"programming language theory","FId":18701968},{"DFN":"Programming language","FN":"programming language","FId":199360897},{"DFN":"Fourth-generation programming language","FN":"fourth generation programming language","FId":145628200},{"DFN":"First-generation programming language","FN":"first generation programming language","FId":570499},{"DFN":"Fifth-generation programming language","FN":"fifth generation programming language","FId":199305712},{"DFN":"Computer science","FN":"computer science","FId":41008148},{"DFN":"Comparison of multi-paradigm programming languages","FN":"comparison of multi paradigm programming languages","FId":74149592}],"E":"{\"DN\":\"A comparison of context-oriented programming languages\",\"IA\":{\"IndexLength\":45,\"InvertedIndex\":{\"Context-oriented\":[0],\"programming\":[1],\"(COP)\":[2],\"extensions\":[3],\"have\":[4],\"been\":[5],\"implemented\":[6],\"for\":[7],\"several\":[8],\"languages.\":[9],\"Each\":[10],\"concrete\":[11],\"language\":[12],\"design\":[13],\"and\":[14,41],\"implementation\":[15],\"comes\":[16],\"with\":[17],\"different\":[18],\"variations\":[19],\"of\":[20,23,34],\"the\":[21,24],\"features\":[22],\"COP\":[25,36],\"paradigm.\":[26],\"In\":[27],\"this\":[28],\"paper,\":[29],\"we\":[30],\"provide\":[31],\"a\":[32],\"comparison\":[33],\"eleven\":[35],\"implementations,\":[37],\"discuss\":[38],\"their\":[39,43],\"designs,\":[40],\"evaluate\":[42],\"performance.\":[44]}},\"S\":[{\"Ty\":3,\"U\":\"http://soft.vub.ac.be/cop09/papers/a6-appeltauer.pdf\"},{\"Ty\":3,\"U\":\"http://www.hirschfeld.org/writings/media/AppeltauerHirschfeldHauptLinckePerscheid_2009_AComparisonOfContextOrientedProgrammingLanguages_AcmDL.pdf\"},{\"Ty\":3,\"U\":\"http://www.hpi.uni-potsdam.de/hirschfeld/publications/media/AppeltauerHirschfeldHauptLinckePerscheid_2009_AComparisonOfContextOrientedProgrammingLanguages_AcmDL.pdf\"},{\"Ty\":1,\"U\":\"https://dl.acm.org/citation.cfm?id=1562118\"},{\"Ty\":0,\"U\":\"http://dl.acm.org/citation.cfm?id=1562118\"}],\"VFN\":\"International Workshop on Context-Oriented Programming\",\"FP\":6,\"DOI\":\"10.1145/1562112.1562118\",\"CC\":{\"1501829296\":[\"It serves the purpose of demonstrating the applicability of a machine model and semantics for multi-dimensional separation of concerns [8] to COP.\"],\"1556513858\":[\"gramming languages were developed, namely ContextS [9] for Smalltalk, ContextR [15] for Ruby, ContextJS for JavaScript, ContextPy [16] and PyContext [17] for Python, and ContextG for Groovy.\"],\"1597389001\":[\"It is implemented as an aspect-oriented precompiler based on the LogicAJ [12] aspect language and provides a more convenient syntax than ContextJ*.\"],\"1992443356\":[\"ContextL [4,5] was the first COP extension to a programming language.\"],\"2014881790\":[\"The cj prototype [13, 14] is an implementation of a minimal subset of ContextJ.\"],\"2075642720\":[\"programming [3], and context-oriented programming (COP)\"],\"2087175184\":[\"gramming languages were developed, namely ContextS [9] for Smalltalk, ContextR [15] for Ruby, ContextJS for JavaScript, ContextPy [16] and PyContext [17] for Python, and ContextG for Groovy.\",\"PyContext [17] suggests the concepts of dynamic variables [7] and implicit layer activation.\"],\"2089889705\":[\"Aside from these dynamic languages, three COP extensions to the Java programming language exist, namely ContextJ [ 1 ], ContextJ* [10], and ContextLogicAJ [2].\\u001bThe rst ideas about a ContextJ language were presented in [5]; a language specication and compiler-based implementation of ContextJ is provided by [ 1 ].\"],\"2097664691\":[\"The cj prototype [13, 14] is an implementation of a minimal subset of ContextJ.\"],\"2115607078\":[\"Another approach to context-orientation is Ambience and its underlying Ambient Object System [6] that is based on Common Lisp.\"],\"2115899208\":[\"Aside from these dynamic languages, three COP extensions to the Java programming language exist, namely ContextJ [1], ContextJ* [10], and ContextLogicAJ [2].\"],\"2138363365\":[\"The separation of cross-cutting concerns is an issue that is considered by several programming language paradigms, such as aspect-oriented programming [ 11 ], feature-oriented programming [3], and context-oriented programming (COP) [10].\"],\"2143238865\":[\"The separation of cross-cutting concerns is an issue that is considered by several programming language paradigms, such as aspect-oriented programming [11], feature-oriented programming [3], and context-oriented programming (COP) [10].\"],\"2150275961\":[\"[10].\",\"For a detailed description of the concepts of COP, we refer to [10]; Section 2.\",\"Aside from these dynamic languages, three COP extensions to the Java programming language exist, namely ContextJ [1], ContextJ* [10], and ContextLogicAJ [2].\"],\"2154597770\":[\"ContextL [4,5] was the first COP extension to a programming language.\",\"The first ideas about a ContextJ language were presented in [5]; a language specification and compiler-based implementation of ContextJ is provided by [1].\"],\"2294229253\":[\"PyContext [17] suggests the concepts of dynamic variables [7] and implicit layer activation.\"]},\"PR\":[2150275961,1992443356,2089889705,2480195817,2087175184,2060640309,1556513858,1978875190,175922506,2115607078,2172169742,1724660581,2138363365,2145919358,1990911977,2145304606,1985637830,2089287449,1649645444,1665004853,2150275961,1992443356,2089889705,2480195817,2087175184,2060640309,1556513858,1978875190,175922506,2115607078,2172169742,1724660581,2138363365,2145919358,1990911977,2145304606,1985637830,2089287449,1649645444,1665004853],\"ANF\":[{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":1},{\"FN\":\"Robert\",\"LN\":\"Hirschfeld\",\"S\":2},{\"FN\":\"Michael\",\"LN\":\"Haupt\",\"S\":3},{\"FN\":\"Jens\",\"LN\":\"Lincke\",\"S\":4},{\"FN\":\"Michael\",\"LN\":\"Perscheid\",\"S\":5}],\"BV\":\"International Workshop on Context-Oriented Programming\",\"BT\":\"p\",\"PB\":\"ACM\"}"},{"logprob":-19.008,"Id":2089889705,"Ty":"0","Ti":"contextj context oriented programming with java","Pt":"1","L":"en@@@ja","Y":2011,"D":"2011-01-01","CC":75,"ECC":117,"RId":[2480195817,2143238865,2075642720,2150275961,2129063689,2070821087,1739798036,1992443356,2065646798,1480731572,2144114063,2118300983,2157920816,2154597770,2115607078,2087175184,956539890,1556513858,83189099,2097664691,2172169742,1490855506,2014881790,2115899208,2002568360],"W":["context","contextj","java","oriented","programming"],"AA":[{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":135591984,"DAfN":"Hasso Plattner Institute","AfN":"hasso plattner institute","AfId":143288331,"S":1},{"DAuN":"Robert Hirschfeld","AuN":"robert hirschfeld","AuId":2154319088,"DAfN":"Hasso Plattner Institute","AfN":"hasso plattner institute","AfId":143288331,"S":2},{"DAuN":"Michael Haupt","AuN":"michael haupt","AuId":2146662369,"DAfN":"Hasso Plattner Institute","AfN":"hasso plattner institute","AfId":143288331,"S":3},{"DAuN":"Hidehiko Masuhara","AuN":"hidehiko masuhara","AuId":2087436944,"DAfN":"University of Tokyo","AfN":"university of tokyo","AfId":74801974,"S":4}],"F":[{"DFN":"strictfp","FN":"strictfp","FId":174954855},{"DFN":"Very high-level programming language","FN":"very high level programming language","FId":169796678},{"DFN":"Real time Java","FN":"real time java","FId":132106392},{"DFN":"Programming language","FN":"programming language","FId":199360897},{"DFN":"Java","FN":"java","FId":548217200},{"DFN":"Higher-order programming","FN":"higher order programming","FId":67478104},{"DFN":"Generics in Java","FN":"generics in java","FId":172482141},{"DFN":"First-generation programming language","FN":"first generation programming language","FId":570499},{"DFN":"Extensible programming","FN":"extensible programming","FId":131531359},{"DFN":"Computer science","FN":"computer science","FId":41008148}],"J":{"JN":"journal of information processing","JId":192843772},"E":"{\"DN\":\"ContextJ: Context-oriented Programming with Java\",\"IA\":{\"IndexLength\":117,\"InvertedIndex\":{\"Context-oriented\":[0],\"programming\":[1,35],\"(COP)\":[2],\"allows\":[3],\"for\":[4,17,32,50],\"the\":[5,33,59,93,108],\"modularization\":[6],\"of\":[7,107,110],\"context-dependent\":[8],\"behavioral\":[9],\"variations.\":[10],\"So\":[11],\"far,\":[12],\"COP\":[13,48],\"has\":[14],\"been\":[15],\"implemented\":[16],\"dynamically-typed\":[18],\"languages\":[19],\"such\":[20],\"as\":[21],\"Lisp,\":[22],\"Smalltalk,\":[23],\"Python,\":[24],\"and\":[25,31,42,71,80,96,100,113],\"Ruby\":[26],\"relying\":[27],\"on\":[28,39],\"reflection\":[29],\"mechanisms,\":[30],\"statically-typed\":[34],\"language\":[36,95],\"Java\":[37,60],\"based\":[38],\"a\":[40,43,69,72],\"library\":[41],\"pre-processor.\":[44],\"ContextJ\":[45,63,94],\"is\":[46,64],\"our\":[47,111],\"implementation\":[49,109],\"Java.\":[51],\"It\":[52],\"properly\":[53],\"integrates\":[54],\"COP’s\":[55],\"layer\":[56],\"concept\":[57],\"into\":[58],\"type\":[61],\"system.\":[62],\"compiler-based.\":[65],\"As\":[66],\"confirmed\":[67],\"by\":[68],\"benchmark\":[70],\"case\":[73],\"study,\":[74],\"it\":[75],\"provides\":[76],\"both\":[77],\"better\":[78],\"performance\":[79],\"higher-level\":[81],\"abstraction\":[82],\"mechanisms\":[83],\"than\":[84],\"its\":[85,98],\"Java-based\":[86],\"predecessors.\":[87],\"In\":[88],\"this\":[89],\"paper,\":[90],\"we\":[91,103],\"present\":[92],\"explain\":[97],\"constructs\":[99],\"semantics.\":[101],\"Further,\":[102],\"give\":[104],\"an\":[105],\"overview\":[106],\"compiler\":[112],\"discuss\":[114],\"run-time\":[115],\"benchmarks.\":[116]}},\"S\":[{\"Ty\":3,\"U\":\"http://prg.is.titech.ac.jp/members/masuhara/papers/jssst2009.pdf\"},{\"Ty\":3,\"U\":\"https://www.jstage.jst.go.jp/article/imt/6/2/6_2_399/_pdf\"},{\"Ty\":1,\"U\":\"http://ci.nii.ac.jp/naid/130000770579\"},{\"Ty\":1,\"U\":\"https://www.jstage.jst.go.jp/article/imt/6/2/6_2_399/_article/-char/ja/\"}],\"VFN\":\"Journal of Information Processing\",\"V\":6,\"I\":2,\"FP\":399,\"LP\":419,\"DOI\":\"10.11185/imt.6.399\",\"PR\":[2150275961,1992443356,2060640309,2144114063,2480195817,175922506,2087175184,1556513858,1978875190,2172169742,2115607078,1724660581,2145304606,2033348393,2089287449,2138363365,6784408,1985637830,1990911977,2115899208,2150275961,1992443356,2060640309,2144114063,2480195817,175922506,2087175184,1556513858,1978875190,2172169742,2115607078,1724660581,2145304606,2033348393,2089287449,2138363365,6784408,1985637830,1990911977,2115899208],\"ANF\":[{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":1},{\"FN\":\"Robert\",\"LN\":\"Hirschfeld\",\"S\":2},{\"FN\":\"Michael\",\"LN\":\"Haupt\",\"S\":3},{\"FN\":\"Hidehiko\",\"LN\":\"Masuhara\",\"S\":4}],\"BV\":\"Journal of Information Processing\",\"BT\":\"a\",\"PB\":\"Information and Media Technologies Editorial Board\"}"},{"logprob":-19.293,"Id":1978875190,"Ty":"0","Ti":"an open implementation for context oriented layer composition in contextjs","Pt":"1","L":"en","Y":2011,"D":"2011-12-01","CC":50,"ECC":76,"RId":[2138363365,2143238865,2014309790,2075642720,2150275961,164488634,2172147300,2129063689,2045723688,1992443356,2065646798,2111898165,2115680394,2076638640,2144114063,2157920816,2089889705,1964757858,2075832738,2154597770,2115607078,2087175184,1527077815,1556513858,1602100009,2014881790,2166901142,1996647866,2115899208,2032415879,2089794420,2101876886,1529505352,2106193618,2002568360,2090124836,1482265802,46244955,2250050941],"W":["composition","context","contextjs","implementation","layer","open","oriented"],"AA":[{"DAuN":"Jens Lincke","AuN":"jens lincke","AuId":2055148755,"DAfN":"Hasso Plattner Institute","AfN":"hasso plattner institute","AfId":143288331,"S":1},{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":135591984,"DAfN":"Hasso Plattner Institute","AfN":"hasso plattner institute","AfId":143288331,"S":2},{"DAuN":"Bastian Steinert","AuN":"bastian steinert","AuId":2142371068,"DAfN":"Hasso Plattner Institute","AfN":"hasso plattner institute","AfId":143288331,"S":3},{"DAuN":"Robert Hirschfeld","AuN":"robert hirschfeld","AuId":2154319088,"DAfN":"Hasso Plattner Institute","AfN":"hasso plattner institute","AfId":143288331,"S":4}],"F":[{"DFN":"Theoretical computer science","FN":"theoretical computer science","FId":80444323},{"DFN":"Open implementation","FN":"open implementation","FId":2781022897},{"DFN":"Distributed computing","FN":"distributed computing","FId":120314980},{"DFN":"Control flow","FN":"control flow","FId":160191386},{"DFN":"Constructed language","FN":"constructed language","FId":94922259},{"DFN":"Computer science","FN":"computer science","FId":41008148},{"DFN":"Composition (visual arts)","FN":"composition","FId":169260993},{"DFN":"Abstraction","FN":"abstraction","FId":124304363}],"J":{"JN":"scp","JId":21029587},"E":"{\"DN\":\"An open implementation for context-oriented layer composition in ContextJS\",\"IA\":{\"IndexLength\":159,\"InvertedIndex\":{\"Context-oriented\":[0],\"programming\":[1],\"(COP)\":[2],\"provides\":[3],\"dedicated\":[4],\"support\":[5],\"for\":[6,27,39,66,73,84,153],\"defining\":[7],\"and\":[8,69,124,147],\"composing\":[9],\"variations\":[10],\"to\":[11,92,109,121,128,132,156],\"a\":[12,22,32],\"basic\":[13],\"program\":[14],\"behavior.\":[15],\"A\":[16],\"variation,\":[17],\"which\":[18],\"is\":[19],\"defined\":[20],\"within\":[21],\"layer,\":[23],\"can\":[24,46,53,102],\"be\":[25,122,133],\"de-/activated\":[26],\"the\":[28,71,94,104,129,137],\"dynamic\":[29,56],\"extent\":[30],\"of\":[31,80,96,139],\"code\":[33],\"block.\":[34],\"While\":[35],\"this\":[36],\"mechanism\":[37],\"allows\":[38],\"control\":[40,61],\"flow-specific\":[41],\"scoping,\":[42],\"expressing\":[43],\"behavior\":[44,67],\"adaptations\":[45,52],\"demand\":[47],\"alternative\":[48],\"scopes.\":[49],\"For\":[50],\"instance,\":[51],\"depend\":[54],\"on\":[55],\"object\":[57],\"structure\":[58],\"rather\":[59],\"than\":[60],\"flow.\":[62],\"We\":[63,90,135],\"present\":[64,148],\"scenarios\":[65],\"adaptation\":[68],\"identify\":[70],\"need\":[72],\"new\":[74,85,149],\"scoping\":[75,81,97,142,150],\"mechanisms.\":[76],\"The\":[77],\"increasing\":[78],\"number\":[79],\"mechanisms\":[82,98,143,151],\"calls\":[83],\"language\":[86,106],\"abstractions\":[87],\"representing\":[88],\"them.\":[89],\"suggest\":[91],\"open\":[93,114],\"implementation\":[95,115,138],\"so\":[99],\"that\":[100,126],\"developers\":[101],\"extend\":[103],\"COP\":[105,141],\"core\":[107],\"according\":[108],\"their\":[110],\"specific\":[111],\"needs.\":[112],\"Our\":[113],\"moves\":[116],\"layer\":[117],\"composition\":[118],\"into\":[119],\"objects\":[120],\"affected\":[123],\"with\":[125],\"closer\":[127],\"method\":[130],\"dispatch\":[131],\"changed.\":[134],\"discuss\":[136],\"established\":[140],\"using\":[144],\"our\":[145,154],\"approach\":[146],\"developed\":[152],\"enhancements\":[155],\"Lively\":[157],\"Kernel.\":[158]}},\"S\":[{\"Ty\":1,\"U\":\"https://www.sciencedirect.com/science/article/pii/S0167642310002121\"},{\"Ty\":1,\"U\":\"http://dblp.uni-trier.de/db/journals/scp/scp76.html#LinckeASH11\"},{\"Ty\":0,\"U\":\"http://www.sciencedirect.com/science/article/pii/S0167642310002121\"}],\"VFN\":\"Science of Computer Programming\",\"V\":76,\"I\":12,\"FP\":1194,\"LP\":1209,\"DOI\":\"10.1016/j.scico.2010.11.013\",\"CC\":{\"46244955\":[\"Morphic, known from Self [38] and Squeak/Smalltalk [20], allows for direct interaction with primitive graphical objects such as rectangles, ellipses, and text fields, that can be composed to more complex objects up to rich user interface applications.\",\"Us changes message passing of Self [38] to incorporate perspectives.\"],\"1482265802\":[\"Our solution is based on an open implementation [23,25] in which layer composition strategies are encapsulated into objects.\"],\"1527077815\":[\"Having conducted several case studies inwhichwe applied COP to various projects [27,26] related to Lively Kernel [21],we identified needs for scoping strategies different from what has been proposed and implemented so far.\"],\"1529505352\":[\"Classboxes [10] support static scoping of behavioral adaptations.\",\"In future work, wewill analyze the applicability of other scopingmechanisms described in the literature, such as implicit layer activation [39] or Classboxes [10].\"],\"2014309790\":[\"Our first example is an adaptation of a xUnit-like test runner2 [9].\"],\"2014881790\":[\"A minimal subset of ContextJ, cj, is implemented for the delMDSOC kernel [31].\"],\"2065646798\":[\"For a comparison of AOP and COP as appropriate representation of behavioral variations, we distinguish between homogeneous and heterogeneous crosscutting concerns [1].\",\"AOP implementations of heterogeneous crosscuts tend to be less understandable to developers than layer-based implementations [1], since they have to mimic COP behavior using pointcuts with dynamic conditions and advice that are complex and fragile for changes.\"],\"2111898165\":[\"Modularization approaches such as traits [34,14] andmixins [11] allow for an additional inheritance relationship next to the class hierarchy, but do not offer dynamic adaptation like layers.\"],\"2154597770\":[\"ContextL [12,13], based on Lisp and the Common Lisp Object System (CLOS), was the first COP extension to a programming language.\"]},\"PR\":[2150275961,1992443356,2144114063,2089889705,2480195817,2060640309,2145304606,1724660581,175922506,2087175184,2342859941,2045723688,2115607078,1556513858,2138363365,1649645444,1985637830,2063274096,6784408,1527077815,2150275961,1992443356,2144114063,2089889705,2480195817,2060640309,2145304606,1724660581,175922506,2087175184,2342859941,2045723688,2115607078,1556513858,2138363365,1649645444,1985637830,2063274096,6784408,1527077815],\"ANF\":[{\"FN\":\"Jens\",\"LN\":\"Lincke\",\"S\":1},{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":2},{\"FN\":\"Bastian\",\"LN\":\"Steinert\",\"S\":3},{\"FN\":\"Robert\",\"LN\":\"Hirschfeld\",\"S\":4}],\"BV\":\"Science of Computer Programming\",\"BT\":\"a\",\"PB\":\"Elsevier\"}"},{"logprob":-19.604,"Id":175922506,"Ty":"0","Ti":"event specific software composition in context oriented programming","Pt":"1","L":"en","Y":2010,"D":"2010-07-01","CC":42,"ECC":75,"RId":[2480195817,2143238865,2075642720,2150275961,1610570299,2113547509,2029414465,2136033258,2070821087,2023546887,25798763,2499711114,2491720856,1992443356,2065646798,1531869376,2111898165,2115680394,2490354173,2144114063,2118300983,2157920816,2089889705,2610644214,1539693001,2159386446,1581096042,2125089485,2154597770,2115607078,2087175184,956539890,1556513858,2492486062,2172169742,1602100009,2014881790,2115899208,2002568360,2115773605,2251542064],"W":["composition","context","event","oriented","programming","software","specific"],"AA":[{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":135591984,"DAfN":"Hasso Plattner Institute","AfN":"hasso plattner institute","AfId":143288331,"S":1},{"DAuN":"Robert Hirschfeld","AuN":"robert hirschfeld","AuId":2154319088,"DAfN":"Hasso Plattner Institute","AfN":"hasso plattner institute","AfId":143288331,"S":2},{"DAuN":"Hidehiko Masuhara","AuN":"hidehiko masuhara","AuId":2087436944,"DAfN":"University of Tokyo","AfN":"university of tokyo","AfId":74801974,"S":3},{"DAuN":"Michael Haupt","AuN":"michael haupt","AuId":2146662369,"DAfN":"Hasso Plattner Institute","AfN":"hasso plattner institute","AfId":143288331,"S":4},{"DAuN":"Kazunori Kawauchi","AuN":"kazunori kawauchi","AuId":2095903912,"DAfN":"University of Tokyo","AfN":"university of tokyo","AfId":74801974,"S":5}],"F":[{"DFN":"Theoretical computer science","FN":"theoretical computer science","FId":80444323},{"DFN":"Programming language","FN":"programming language","FId":199360897},{"DFN":"Modular programming","FN":"modular programming","FId":88482812},{"DFN":"Java","FN":"java","FId":548217200},{"DFN":"Function composition (computer science)","FN":"function composition","FId":104637301},{"DFN":"Control flow","FN":"control flow","FId":160191386},{"DFN":"Constructed language","FN":"constructed language","FId":94922259},{"DFN":"Computer science","FN":"computer science","FId":41008148},{"DFN":"Composition (visual arts)","FN":"composition","FId":169260993},{"DFN":"Abstraction","FN":"abstraction","FId":124304363}],"J":{"JN":"soco","JId":65753830},"E":"{\"DN\":\"Event-specific software composition in context-oriented programming\",\"IA\":{\"IndexLength\":85,\"InvertedIndex\":{\"Context-oriented\":[0],\"programming\":[1],\"(COP)\":[2],\"introduces\":[3],\"dedicated\":[4],\"abstractions\":[5],\"for\":[6,22,38,67],\"the\":[7,31],\"modularization\":[8],\"and\":[9,70,74],\"dynamic\":[10],\"composition\":[11,69],\"of\":[12,34],\"crosscutting\":[13],\"context-specific\":[14],\"functionality.\":[15],\"While\":[16],\"existing\":[17],\"COP\":[18,81],\"languages\":[19],\"offer\":[20],\"constructs\":[21,66],\"control-flow\":[23],\"specific\":[24],\"composition,\":[25],\"they\":[26],\"do\":[27],\"not\":[28],\"yet\":[29],\"consider\":[30],\"explicit\":[32,71],\"representation\":[33,73],\"event-specific\":[35,68],\"context-dependent\":[36],\"behavior,\":[37],\"which\":[39],\"we\":[40,62],\"observe\":[41],\"two\":[42],\"distinguishing\":[43],\"properties:\":[44],\"First,\":[45],\"context\":[46,72],\"can\":[47,54],\"affect\":[48],\"several\":[49],\"control\":[50],\"flows.\":[51],\"Second,\":[52],\"events\":[53],\"establish\":[55],\"new\":[56,64],\"contexts\":[57],\"asynchronously.\":[58],\"In\":[59],\"this\":[60],\"paper,\":[61],\"propose\":[63],\"language\":[65],\"introduce\":[75],\"their\":[76],\"implementation\":[77],\"in\":[78],\"JCop,\":[79],\"our\":[80],\"extension\":[82],\"to\":[83],\"Java.\":[84]}},\"S\":[{\"Ty\":3,\"U\":\"http://www.hirschfeld.org/writings/media/AppeltauerHirschfeldMasuharaHauptKawauchi_2010_EventSpecificSoftwareCompositionInContextOrientedProgramming_SpringerLNCS.pdf\"},{\"Ty\":3,\"U\":\"http://www.hpi.uni-potsdam.de/hirschfeld/publications/media/AppeltauerHirschfeldMasuharaHauptKawauchi_2010_EventSpecificSoftwareCompositionInContextOrientedProgramming_SpringerLNCS.pdf\"},{\"Ty\":1,\"U\":\"https://link.springer.com/chapter/10.1007/978-3-642-14046-4_4\"},{\"Ty\":1,\"U\":\"https://rd.springer.com/content/pdf/10.1007%2F978-3-642-14046-4_4.pdf\"}],\"VFN\":\"Soft Computing\",\"FP\":50,\"LP\":65,\"DOI\":\"10.1007/978-3-642-14046-4_4\",\"CC\":{\"956539890\":[\"In some languages, such as CaesarJ [6], aspects can be deployed for a dynamic extent at run-time, much like explicit with statements.\"],\"1539693001\":[\"In Ptolemy [28], code blocks are bound to events, similar to pointcut-advice binding in AOP.\"],\"1556513858\":[\"Most COP extensions have been developed for dynamic languages, such as Lisp [13, 14] Smalltalk [21], Python [31, 23], and the delMDSOC kernel [29].\"],\"1581096042\":[\"EventJava [17] models events as asynchronous methods and compound events by correlation patterns.\"],\"1602100009\":[\"Modularization approaches such as traits [30,15] andmixins [12] allow for an additional inheritance relationship next to the class hierarchy, but do not offer dynamic adaptation like layers.\"],\"1992443356\":[\"Most COP extensions have been developed for dynamic languages, such as Lisp [13, 14] Smalltalk [21], Python [31, 23], and the delMDSOC kernel [29].\"],\"2002568360\":[\"Most COP extensions have been developed for dynamic languages, such as Lisp [13, 14] Smalltalk [21], Python [31, 23], and the delMDSOC kernel [29].\"],\"2014881790\":[\"Most COP extensions have been developed for dynamic languages, such as Lisp [13, 14] Smalltalk [21], Python [31, 23], and the delMDSOC kernel [29].\"],\"2023546887\":[\"COP provides layers [9] as a modularization concept that can crosscut an object-oriented decomposition and encapsulate context-specific behavioral variations, represented as partial method definitions.\"],\"2065646798\":[\"More formally, we identify two different kinds of cross-cutting concerns, according to [1]: The actual behavioral variations implemented using layers are heterogeneous concerns, therefore they should be defined close to their respective objects.\"],\"2070821087\":[\"5 specification JastAddJ [16].\"],\"2075642720\":[\"Feature-oriented programming (FOP) [10] and its Java-based implementation AHEAD [8] provide layer-like modules to specify adaptations of methods and classes (and other software artifacts).\"],\"2087175184\":[\"Most COP extensions have been developed for dynamic languages, such as Lisp [13, 14] Smalltalk [21], Python [31, 23], and the delMDSOC kernel [29].\",\"Except for the Python extension PyContext [31] that provides implicit layer activation, none of the mentioned languages support event-based layer activation.\"],\"2111898165\":[\"Modularization approaches such as traits [30,15] andmixins [12] allow for an additional inheritance relationship next to the class hierarchy, but do not offer dynamic adaptation like layers.\"],\"2115607078\":[\"Based on the Ambient Object System [19], it supports behavior adaptations with partial method definitions and context objects, which correspond to COP layers.\"],\"2115680394\":[\"the definition of adaptations from their composition, distinguishing it from alternative multi-dimensional modularization techniques such as aspect-oriented programming [26] (AOP), Mixins [12], or Classboxes [11].\",\"Modularization approaches such as traits [30,15] andmixins [12] allow for an additional inheritance relationship next to the class hierarchy, but do not offer dynamic adaptation like layers.\"],\"2115773605\":[\"The CaesarJ extension ECaesarJ [27] supports the definition of context as a class implementing two events representing context entry and exit.\"],\"2115899208\":[\"In this paper, we motivate the need for explicit representation of event-specific context-dependent composition along a case study that we conducted using ContextJ [5, 3], our earlier COP extension to the Java programming language.\"],\"2118300983\":[\"The JCop compiler is implemented based on the JastAdd [20] meta-compiler framework and extends the Java 1.\"],\"2125089485\":[\"the definition of adaptations from their composition, distinguishing it from alternative multi-dimensional modularization techniques such as aspect-oriented programming [26] (AOP), Mixins [12], or Classboxes [11].\",\"The Classbox/J [11] module system extends Java’s packaging and scoping mechanism.\"],\"2136033258\":[\"In addition, we adopted the AspectJ method pattern grammar used by the abc compiler [7].\"],\"2143238865\":[\"the definition of adaptations from their composition, distinguishing it from alternative multi-dimensional modularization techniques such as aspect-oriented programming [26] (AOP), Mixins [12], or Classboxes [11].\",\"To address the issue of scattered with statements, we adopted features of AOP [26, 18], where scattered functionality is expressed by advice blocks bound to pointcuts quantifying over a set of join points, well-defined events in the execution graph.\"],\"2144114063\":[\"The COP languages implemented so far [2] support selective activation and deactivation of layer compositions, expressing programmatically when the application enters and leaves certain contexts.\",\"ContextJ [2, 3] is a COP implementation for Java.\",\"Layers can either be defined within the classes for which they provide behavioral variations (layer-in-class), or in a dedicated top-level layer similar to an aspect (class-in-layer) [22, 2].\",\"A detailed comparison of COP language features is provided in [2].\"],\"2150275961\":[\"Context-oriented programming [22] (COP) is an approach to representing context-specific concerns, focusing on dynamic composition of control flows.\",\"Layers can either be defined within the classes for which they provide behavioral variations (layer-in-class), or in a dedicated top-level layer similar to an aspect (class-in-layer) [22, 2].\"],\"2154597770\":[\"Most COP extensions have been developed for dynamic languages, such as Lisp [13, 14] Smalltalk [21], Python [31, 23], and the delMDSOC kernel [29].\"],\"2157920816\":[\"Feature-oriented programming (FOP) [10] and its Java-based implementation AHEAD [8] provide layer-like modules to specify adaptations of methods and classes (and other software artifacts).\"],\"2172169742\":[\"As a case study [4], we have developed a little IDE using ContextJ, whose GUI provides context-specific behavior.\"],\"2480195817\":[\"This feature has been previously introduced by other languages such as Common Lisp [24] and AspectJ [25].\",\"It contains an AspectJ-like method pattern [25] specifying those methods to whose dynamic extent a layer composition is to be applied.\",\"AspectJ [25] is a popular Java language extension that established the notion of join points, well-defined events in the execution of a program that can be described by pointcut predicates and can be adapted by advice blocks.\"]},\"PR\":[2150275961,2060640309,2089889705,1992443356,2144114063,2480195817,2145304606,1724660581,2087175184,1978875190,2172169742,2115607078,6784408,2000399282,1531869376,2033348393,1539693001,1556513858,1985637830,2032835129,2150275961,2060640309,2089889705,1992443356,2144114063,2480195817,2145304606,1724660581,2087175184,1978875190,2172169742,2115607078,6784408,2000399282,1531869376,2033348393,1539693001,1556513858,1985637830,2032835129],\"ANF\":[{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":1},{\"FN\":\"Robert\",\"LN\":\"Hirschfeld\",\"S\":2},{\"FN\":\"Hidehiko\",\"LN\":\"Masuhara\",\"S\":3},{\"FN\":\"Michael\",\"LN\":\"Haupt\",\"S\":4},{\"FN\":\"Kazunori\",\"LN\":\"Kawauchi\",\"S\":5}],\"BV\":\"Soft Computing\",\"BT\":\"a\",\"PB\":\"Springer, Berlin, Heidelberg\"}"},{"logprob":-19.833,"Id":2111576674,"Ty":"0","Ti":"declarative layer composition with the jcop programming language","Pt":"1","Y":2013,"D":"2013-01-01","CC":20,"ECC":20,"RId":[2138363365,1967661515,1882088395,2480195817,2143238865,41699526,2075642720,2126225516,1739798036,1992443356,2065646798,2157920816,2089889705,1539693001,1978875190,1581096042,2115607078,2161291379,1724660581,956539890,1556513858,2172169742,2000399282,1597389001,2014881790,2032415879,2002568360,2090124836,2006015625,1990628165,2027457117,2115773605,2037048706,2105053310,140370410],"W":["composition","declarative","jcop","language","layer","programming"],"AA":[{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":135591984,"S":1},{"DAuN":"Robert Hirschfeld","AuN":"robert hirschfeld","AuId":2154319088,"S":2},{"DAuN":"Jens Lincke","AuN":"jens lincke","AuId":2055148755,"S":3}],"F":[{"DFN":"Source code","FN":"source code","FId":43126263},{"DFN":"Separation of concerns","FN":"separation of concerns","FId":76214141},{"DFN":"Programming language","FN":"programming language","FId":199360897},{"DFN":"Language construct","FN":"language construct","FId":48859967},{"DFN":"Implementation","FN":"implementation","FId":26713055},{"DFN":"Control flow","FN":"control flow","FId":160191386},{"DFN":"Computer science","FN":"computer science","FId":41008148},{"DFN":"Composition (visual arts)","FN":"composition","FId":169260993}],"J":{"JN":"the journal of object technology","JId":172897590},"E":"{\"DN\":\"Declarative Layer Composition with the JCop Programming Language\",\"IA\":{\"IndexLength\":264,\"InvertedIndex\":{\"Program\":[0],\"behavior\":[1,41,114,134],\"that\":[2,57,184,217,235],\"relies\":[3],\"on\":[4],\"contextual\":[5],\"information,\":[6],\"such\":[7],\"as\":[8,123,180],\"physical\":[9],\"location\":[10],\"or\":[11],\"network\":[12],\"accessibility,\":[13],\"is\":[14,28,100,135],\"common\":[15],\"in\":[16,115,198,202],\"today's\":[17],\"appli-\":[18],\"cations,\":[19],\"yet\":[20],\"its\":[21],\"representation\":[22],\"at\":[23,154],\"the\":[24,83,86,90,103,129,142,146,186,209,253],\"source\":[25,84,98,130],\"code\":[26,99,144,221],\"level\":[27],\"not\":[29],\"suciently\":[30],\"supported\":[31],\"by\":[32,121],\"programming\":[33],\"languages.\":[34],\"With\":[35],\"context-oriented\":[36],\"program-\":[37],\"ming\":[38],\"(COP),\":[39],\"context-dependent\":[40,61,113,133],\"can\":[42],\"be\":[43,73,118,152],\"explicitly\":[44],\"modularized\":[45],\"and\":[46,63,259],\"dynamically\":[47],\"activated.\":[48],\"The\":[49,108],\"available\":[50],\"COP\":[51,93,122,241],\"implementations\":[52],\"oer\":[53],\"lan-\":[54],\"guage\":[55],\"constructs\":[56,79],\"allow\":[58],\"to\":[59,64,82,94,102,128,165,220],\"describe\":[60],\"functionality\":[62,71],\"specify\":[65],\"for\":[66,208],\"which\":[67,162],\"control\":[68,111,139,158,176],\"flows\":[69],\"this\":[70,124,170,191,244],\"should\":[72],\"exe-\":[74],\"cuted.\":[75],\"Since\":[76],\"these\":[77,157],\"language\":[78,251],\"require\":[80],\"modifications\":[81],\"code,\":[85],\"contemporary\":[87],\"approaches\":[88],\"limit\":[89],\"use\":[91],\"of\":[92,156,169,188,212,215,256,261],\"program\":[95],\"parts\":[96],\"whose\":[97],\"accessible\":[101],\"developer\":[104],\"(the\":[105],\"user\":[106,147],\"code).\":[107],\"dy-\":[109],\"namic\":[110],\"over\":[112,177],\"frameworks\":[116],\"cannot\":[117],\"directly\":[119],\"addressed\":[120,136,153],\"would\":[125],\"imply\":[126],\"changes\":[127],\"code.\":[131,148],\"Instead,\":[132],\"whenever\":[137],\"a\":[138,166,173,181,226,229,239],\"flow\":[140,159],\"from\":[141],\"framework\":[143],\"enters\":[145],\"Context\":[149],\"composition\":[150,197,258],\"must\":[151],\"any\":[155],\"entry\":[160],\"points,\":[161],\"may\":[163],\"lead\":[164,219],\"redundant\":[167],\"specification\":[168],\"functionality.\":[171],\"As\":[172],\"result,\":[174],\"dynamic\":[175],\"layers\":[178,216],\"emerges\":[179],\"crosscutting\":[182,195],\"concern\":[183],\"obstructs\":[185],\"separation\":[187],\"concerns.\":[189],\"In\":[190],\"article,\":[192],\"we\":[193,205,236,246],\"discuss\":[194,206],\"layer\":[196,257,262],\"framework-\":[199],\"based\":[200],\"applications\":[201],\"detail.\":[203],\"Moreover,\":[204],\"limitations\":[207],\"ex-\":[210],\"pression\":[211],\"semantic\":[213],\"relationships\":[214],\"might\":[218],\"du-\":[222],\"plication.\":[223],\"We\":[224],\"present\":[225],\"framework-based\":[227],\"application,\":[228],\"simple\":[230],\"action\":[231],\"ad-\":[232],\"venture\":[233],\"game\":[234],\"implemented\":[237],\"using\":[238],\"conventional\":[240],\"language.\":[242],\"Along\":[243],\"example,\":[245],\"show\":[247],\"how\":[248],\"our\":[249],\"JCop\":[250],\"supports\":[252],\"decla-\":[254],\"ration\":[255],\"expression\":[260],\"relationships.\":[263]}},\"S\":[{\"Ty\":3,\"U\":\"http://www.jot.fm/issues/issue_2013_06/article4.pdf\"},{\"Ty\":1,\"U\":\"http://www.jot.fm/contents/issue_2013_06/article4.html\"},{\"Ty\":1,\"U\":\"http://dblp.uni-trier.de/db/journals/jot/jot12.html#AppeltauerHL13\"}],\"VFN\":\"The Journal of Object Technology\",\"V\":12,\"I\":2,\"DOI\":\"10.5381/jot.2013.12.2.a4\",\"PR\":[2150275961,2144114063,2129732645,169634360,1992443356,2090124836,2156011560,2469053383,2754864316,2527095743,2297998882,2296688603,2293157443,2623403331,2093659090,2084028549,2555016675,2267923570,1554217755,175223090,2150275961,2144114063,2129732645,169634360,1992443356,2090124836,2156011560,2469053383,2754864316,2527095743,2297998882,2296688603,2293157443,2623403331,2093659090,2084028549,2555016675,2267923570,1554217755,175223090],\"ANF\":[{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":1},{\"FN\":\"Robert\",\"LN\":\"Hirschfeld\",\"S\":2},{\"FN\":\"Jens\",\"LN\":\"Lincke\",\"S\":3}],\"BV\":\"The Journal of Object Technology\",\"BT\":\"a\"}"},{"logprob":-20.084,"Id":2172169742,"Ty":"0","Ti":"improving the development of context dependent java applications with contextj","Pt":"0","L":"en","Y":2009,"D":"2009-07-07","CC":27,"ECC":27,"RId":[2138363365,2480195817,2143238865,2075642720,2150275961,1739798036,1992443356,1531869376,2157920816,2089889705,2154597770,2087175184,956539890,1556513858],"W":["applications","context","contextj","dependent","development","improving","java"],"AA":[{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":135591984,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":1},{"DAuN":"Robert Hirschfeld","AuN":"robert hirschfeld","AuId":2154319088,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":2},{"DAuN":"Hidehiko Masuhara","AuN":"hidehiko masuhara","AuId":2087436944,"DAfN":"University of Tokyo","AfN":"university of tokyo","AfId":74801974,"S":3}],"F":[{"DFN":"Real time Java","FN":"real time java","FId":132106392},{"DFN":"Programming paradigm","FN":"programming paradigm","FId":34165917},{"DFN":"Programming language","FN":"programming language","FId":199360897},{"DFN":"Programming domain","FN":"programming domain","FId":119263510},{"DFN":"Java","FN":"java","FId":548217200},{"DFN":"Graphical user interface","FN":"graphical user interface","FId":37789001},{"DFN":"Fourth-generation programming language","FN":"fourth generation programming language","FId":145628200},{"DFN":"Fifth-generation programming language","FN":"fifth generation programming language","FId":199305712},{"DFN":"Event-driven programming","FN":"event driven programming","FId":77362995},{"DFN":"Computer science","FN":"computer science","FId":41008148}],"E":"{\"DN\":\"Improving the development of context-dependent Java applications with ContextJ\",\"IA\":{\"IndexLength\":68,\"InvertedIndex\":{\"Context-oriented\":[0],\"programming\":[1,19],\"languages\":[2],\"ease\":[3],\"the\":[4,17,26,33,54],\"design\":[5],\"and\":[6,58],\"implementation\":[7],\"of\":[8,28,35],\"context-dependent\":[9],\"applications.\":[10],\"ContextJ\":[11,29,51,63],\"is\":[12],\"a\":[13,36,43],\"context-oriented\":[14],\"extension\":[15],\"to\":[16,62,64],\"Java\":[18],\"language.\":[20],\"In\":[21],\"this\":[22],\"paper,\":[23],\"we\":[24],\"assess\":[25],\"applicability\":[27],\"language\":[30],\"abstractions\":[31],\"for\":[32],\"development\":[34],\"graphical\":[37],\"user\":[38],\"interface-based\":[39],\"application.\":[40],\"We\":[41],\"present\":[42],\"text\":[44],\"editor\":[45],\"that\":[46],\"has\":[47],\"been\":[48],\"implemented\":[49],\"with\":[50],\"based\":[52],\"on\":[53],\"Qt\":[55],\"Jambi\":[56],\"framework\":[57],\"discuss\":[59],\"possible\":[60],\"extensions\":[61],\"improve\":[65],\"its\":[66],\"applicability.\":[67]}},\"S\":[{\"Ty\":3,\"U\":\"http://www.hpi.uni-potsdam.de/hirschfeld/publications/media/AppeltauerHirschfeldMasuhara_2009_ImprovingTheDevelopmentOfContextDependentJavaApplicationsWithContextJ_AcmDL.pdf\"},{\"Ty\":3,\"U\":\"http://soft.vub.ac.be/cop09/papers/a5-appeltauer.pdf\"},{\"Ty\":3,\"U\":\"http://www.hirschfeld.org/writings/media/AppeltauerHirschfeldMasuhara_2009_ImprovingTheDevelopmentOfContextDependentJavaApplicationsWithContextJ_AcmDL.pdf\"},{\"Ty\":1,\"U\":\"https://dl.acm.org/ft_gateway.cfm?id=1562117&type=pdf\"},{\"Ty\":1,\"U\":\"https://doi.acm.org/10.1145/1562112.1562117\"}],\"VFN\":\"International Workshop on Context-Oriented Programming\",\"FP\":5,\"DOI\":\"10.1145/1562112.1562117\",\"CC\":{\"956539890\":[\"Java-based aspect-oriented programming languages, such as AspectJ [9] or CaesarJ [2], also provide abstractions to modularize crosscutting concerns but focus on functionality that is repeatedly used at different points in a program.\",\"The CaesarJ [2] language unifies classes, aspects, and packages.\"],\"1531869376\":[\"Java-based aspect-oriented programming languages, such as AspectJ [9] or CaesarJ [ 2 ], also provide abstractions to modularize crosscutting concerns but focus on functionality that is repeatedly used at dierent points in a program.\\u001bThe CaesarJ [ 2 ] language unies classes, aspects, and packages.\"],\"1556513858\":[\"Several COP extensions have been developed for dynamic programming languages such as Lisp [5], Smalltalk [ 7 ], Python [14,15], and Ruby [13].\"],\"1739798036\":[\"CaesarJ supports virtual classes [11], a concept that enables dynamic class extension, depending on the caller’s scope.\"],\"1992443356\":[\"Several COP extensions have been developed for dynamic programming languages such as Lisp [ 5 ], Smalltalk [7], Python [14,15], and Ruby [13].\"],\"2075642720\":[\"The maintenance and development of software productlines is addressed by feature-oriented programming [4].\"],\"2087175184\":[\"Several COP extensions have been developed for dynamic programming languages such as Lisp [5], Smalltalk [7], Python [14, 15 ], and Ruby [13].\"],\"2089889705\":[\"ContextJ [ 1 ] is our compiler-based COP extension to the\"],\"2138363365\":[\"Such distributed functionality is denoted as crosscutting concern [ 10 ].\"],\"2143238865\":[\"Such distributed functionality is denoted as crosscutting concern [10].\"],\"2150275961\":[\"Context-oriented programming [8] (COP) addresses the development of systems, whose behavior varies depending on their context of use.\",\"Context that requires a composition of behavioral variations can be everything that is computationally accessible [8], such as state, control flow, or properties of the system’s environment.\",\"2 ContextJ The ContextJ programming language features the layersin-class style [8]: each class affected by a layer L contains a declaration of L that contains partial methods for its class.\",\"The first Java-based prototype is ContextJ* [8], a Java library that implements the core concepts of COP.\"],\"2154597770\":[\"First ideas about a COP language extension to Java have been presented in [6], but neither provide a language specification, nor an implementation.\"],\"2157920816\":[\"The Java-based AHEAD Tool Suite [3] provides a Java language extension supporting constructs such as class refinements for static feature-oriented composition.\"],\"2480195817\":[\"Java-based aspect-oriented programming languages, such as AspectJ [9] or CaesarJ [2], also provide abstractions to modularize crosscutting concerns but focus on functionality that is repeatedly used at different points in a program.\"]},\"PR\":[2150275961,2089889705,2144114063,1992443356,2480195817,1556513858,175922506,2087175184,2115607078,2060640309,1724660581,1539693001,1581096042,1531869376,1978875190,2143238865,2145304606,2014881790,2032835129,2075642720,2150275961,2089889705,2144114063,1992443356,2480195817,1556513858,175922506,2087175184,2115607078,2060640309,1724660581,1539693001,1581096042,1531869376,1978875190,2143238865,2145304606,2014881790,2032835129,2075642720],\"ANF\":[{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":1},{\"FN\":\"Robert\",\"LN\":\"Hirschfeld\",\"S\":2},{\"FN\":\"Hidehiko\",\"LN\":\"Masuhara\",\"S\":3}],\"BV\":\"International Workshop on Context-Oriented Programming\",\"BT\":\"p\",\"PB\":\"ACM\"}"},{"logprob":-20.307,"Id":53517318,"Ty":"0","Ti":"fine grained generic aspects","Pt":"0","Y":2006,"D":"2006-01-01","CC":31,"ECC":31,"RId":[2480195817,1851327982,2136033258,1965418329,2100165879,2135522367,2067897422,2098794871,1549128618,1963934148,221784231,287119291,121653775,185604728,182762056,1582822229,1509493653],"W":["aspects","fine","generic","grained"],"AA":[{"DAuN":"Tobias Rho","AuN":"tobias rho","AuId":2140223330,"DAfN":"University of Bonn","AfN":"university of bonn","AfId":135140700,"S":1},{"DAuN":"Günter Kniesel","AuN":"gunter kniesel","AuId":729669163,"DAfN":"University of Bonn","AfN":"university of bonn","AfId":135140700,"S":2},{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":2796791905,"DAfN":"University of Bonn","AfN":"university of bonn","AfId":135140700,"S":3}],"F":[{"DFN":"Programming language","FN":"programming language","FId":199360897},{"DFN":"Program transformation","FN":"program transformation","FId":2778361913},{"DFN":"Pointcut","FN":"pointcut","FId":2776219908},{"DFN":"Limiting","FN":"limiting","FId":188198153},{"DFN":"Expressive power","FN":"expressive power","FId":195818886},{"DFN":"Expression (mathematics)","FN":"expression","FId":76482347},{"DFN":"Computer science","FN":"computer science","FId":41008148},{"DFN":"AspectJ","FN":"aspectj","FId":2781009160}],"E":"{\"DN\":\"Fine-Grained Generic Aspects\",\"IA\":{\"IndexLength\":135,\"InvertedIndex\":{\"In\":[0,44],\"theory,\":[1],\"join\":[2,42],\"points\":[3],\"can\":[4,122],\"be\":[5],\"arbitrary\":[6],\"places\":[7],\"in\":[8,87],\"the\":[9,24,39,63,93,113],\"structure\":[10],\"or\":[11,130],\"execution\":[12],\"of\":[13,28,38,66,68,81,95,117],\"a\":[14,36,49],\"program.\":[15],\"However,\":[16],\"most\":[17],\"existing\":[18],\"aspect\":[19],\"languages\":[20,34],\"do\":[21],\"not\":[22],\"support\":[23],\"full\":[25],\"expressive\":[26],\"power\":[27,102],\"this\":[29,45],\"concept,\":[30],\"limiting\":[31],\"their\":[32,101],\"pointcut\":[33],\"to\":[35,75,109],\"subset\":[37],\"theoretically\":[40],\"possible\":[41],\"points.\":[43],\"paper\":[46],\"we\":[47],\"explore\":[48],\"minimal\":[50],\"language\":[51,91,133],\"design\":[52],\"based\":[53],\"on\":[54],\"only\":[55],\"three\":[56],\"built-in\":[57],\"fine-grained\":[58,82,96],\"pointcuts,\":[59],\"which\":[60],\"enable\":[61],\"expressing\":[62],\"entire\":[64],\"spectrum\":[65],\"structures\":[67],\"an\":[69],\"underlying\":[70],\"base\":[71],\"language,\":[72],\"from\":[73],\"types\":[74],\"statements\":[76],\"and\":[77,111,119],\"expressions.\":[78],\"The\":[79],\"combination\":[80],\"pointcuts\":[83,116],\"with\":[84],\"uniform\":[85],\"genericity\":[86],\"our\":[88],\"LogicAJ\":[89],\"2\":[90],\"yields\":[92],\"concept\":[94],\"generic\":[97],\"aspects.\":[98],\"We\":[99],\"demonstrate\":[100],\"by\":[103],\"showing\":[104],\"how\":[105,120],\"they\":[106,121],\"allow\":[107],\"programmers\":[108],\"express\":[110],\"extend\":[112],\"static\":[114],\"primitive\":[115],\"AspectJ\":[118],\"model\":[123],\"applications\":[124],\"that\":[125],\"previously\":[126],\"required\":[127],\"run-time\":[128],\"reflection\":[129],\"special\":[131],\"purpose\":[132],\"extensions.\":[134]}},\"S\":[{\"Ty\":3,\"U\":\"http://www.cs.ucf.edu/~leavens/FOAL/slides-2006/Rho-Kniesel-Appeltauer.pdf\"}],\"VFN\":\"FOAL\",\"CC\":{\"121653775\":[\"Different researchers [7], [6], [17], [9] have noted independently that finer grained join points are necessary in various application areas.\",\"Rajan [17] address the same problem domain but provide a solution at a higher level of abstraction.\"],\"182762056\":[\"introduce JaTS [2], a language for pattern based transformations of Java programs.\"],\"221784231\":[\"Contract4J [20] uses AspectJ to check contracts on Java.\"],\"287119291\":[\"Different researchers [7], [6], [17], [9] have noted independently that finer grained join points are necessary in various application areas.\",\"In LoopsAJ [6] they provide a solution tailored specifically to the interception of loops.\",\"2 Example High-Performance Computing The following section shows how the execution of highly parallel loops can be distributed by a generic aspect onto a set of threads, following the approach described in [6].\",\"Unlike the approach in [6] our solution does not rely on code conventions.\",\"Harbulot presents LoopAJ [6], an AspectJ extension for loop pointcuts.\"],\"1549128618\":[\"The TyRuBa language [19] introduces logic meta-programming for Java programs by defining Prolog-like predicates on Java programs.\"],\"1582822229\":[\"Join points are well-defined places in the ture or execution of a [4] , [5] , [3] , [ 21 ] , [16] . In theory, they could be arbitrar y program or run-time events.\"],\"1851327982\":[\"Join points are well-defined places in the structure or execution flow of a program [4], [5], [3], [21], [16].\"],\"1963934148\":[\"Section 4.1 presents a simple check for the static variant of the Law of Demeter, expressing a contract previously claimed to require extension of AspectJ by statically executable advice [ 14 ].\"],\"2067897422\":[\"Different researchers [7], [6], [17], [9] have noted independently that finer grained join points are necessary in various application areas.\",\"Gurd [7] demonstrate that with AspectJ [8] parallelization of such loops is only possible after refactoring the loop into a new method with a defined signature pattern that makes its lower and upper bounds explicit.\"],\"2098794871\":[\"The Law of Demeter (LoD) [13] restricts the method calls used in a class C to methods from ‘known’ types.\"],\"2100165879\":[\"General software transformation approaches, like [ 18 ] have addressed optimizations techniques like partial evaluation and data-flow optimization with generic transformations.\"],\"2135522367\":[\"Join points are well-defined places in the structure or execution flow of a program [4], [5], [3], [21], [ 16 ].\"]},\"PR\":[2480195817,2013071456,2138363365,1649645444,2079777989,148107450,1608143967,1539693001,121653775,123316651,1500536239,2040348150,2067897422,2105379554,2106731015,2116244845,2117153488,2122933544,2126225516,2244034457,2480195817,2013071456,2138363365,1649645444,2079777989,148107450,1608143967,1539693001,121653775,123316651,1500536239,2040348150,2067897422,2105379554,2106731015,2116244845,2117153488,2122933544,2126225516,2244034457],\"ANF\":[{\"FN\":\"Tobias\",\"LN\":\"Rho\",\"S\":1},{\"FN\":\"Günter\",\"LN\":\"Kniesel\",\"S\":2},{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":3}],\"BV\":\"FOAL\",\"BT\":\"a\"}"},{"logprob":-20.37,"Id":2115899208,"Ty":"0","Ti":"dedicated programming support for context aware ubiquitous applications","Pt":"3","L":"en","Y":2008,"D":"2008-09-01","CC":19,"ECC":19,"RId":[2480195817,2131415946,2150275961,1610570299,2012173916,2162673707,2150491652,2048440355,2000090290,170057163,2161291379,1597389001,1513110806,2160377668,169400382],"W":["applications","aware","context","dedicated","programming","support","ubiquitous"],"AA":[{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":135591984,"DAfN":"Hasso Plattner Institute","AfN":"hasso plattner institute","AfId":143288331,"S":1},{"DAuN":"Robert Hirschfeld","AuN":"robert hirschfeld","AuId":2154319088,"DAfN":"Hasso Plattner Institute","AfN":"hasso plattner institute","AfId":143288331,"S":2},{"DAuN":"Tobias Rho","AuN":"tobias rho","AuId":2140223330,"DAfN":"University of Bonn","AfN":"university of bonn","AfId":135140700,"S":3}],"F":[{"DFN":"Ubiquitous computing","FN":"ubiquitous computing","FId":172195944},{"DFN":"Software evolution","FN":"software evolution","FId":202105479},{"DFN":"Separation of concerns","FN":"separation of concerns","FId":76214141},{"DFN":"Reactive programming","FN":"reactive programming","FId":150762246},{"DFN":"Mobile telephony","FN":"mobile telephony","FId":95491727},{"DFN":"Mobile computing","FN":"mobile computing","FId":144543869},{"DFN":"Java","FN":"java","FId":548217200},{"DFN":"Distributed computing","FN":"distributed computing","FId":120314980},{"DFN":"Context awareness","FN":"context awareness","FId":2781368080},{"DFN":"Computer science","FN":"computer science","FId":41008148}],"C":{"CN":"ucs","CId":1171708086},"E":"{\"DN\":\"Dedicated Programming Support for Context-Aware Ubiquitous Applications\",\"IA\":{\"IndexLength\":85,\"InvertedIndex\":{\"Ubiquitous\":[0],\"mobile\":[1,83],\"applications\":[2,22],\"often\":[3],\"require\":[4],\"dynamic\":[5],\"context\":[6],\"information\":[7],\"for\":[8,19,61],\"user-specific\":[9],\"computation.\":[10],\"However,\":[11],\"state-of-the-art\":[12],\"platforms,\":[13],\"frameworks,\":[14],\"and\":[15,46,51,77],\"programming\":[16,75],\"languages\":[17],\"used\":[18],\"developing\":[20],\"such\":[21],\"do\":[23],\"not\":[24],\"directly\":[25],\"support\":[26],\"context-dependent\":[27],\"behavior\":[28],\"with\":[29,38],\"first\":[30],\"class\":[31],\"entities.\":[32],\"Instead,\":[33],\"context-aware\":[34],\"functionality\":[35],\"is\":[36],\"tangled\":[37],\"the\":[39,73],\"application's\":[40],\"core\":[41],\"concerns,\":[42],\"which\":[43],\"increases\":[44],\"complexity,\":[45],\"hinders\":[47],\"separation\":[48],\"of\":[49,68,80],\"concerns\":[50],\"further\":[52],\"software\":[53],\"evolution.\":[54],\"This\":[55],\"paper\":[56],\"motivates\":[57],\"Context-oriented\":[58],\"Programming\":[59],\"(COP)\":[60],\"ubiquitous\":[62],\"computing.\":[63],\"It\":[64],\"presents\":[65],\"an\":[66],\"overview\":[67],\"our\":[69],\"COP\":[70],\"extension\":[71],\"to\":[72],\"Java\":[74],\"language\":[76],\"a\":[78,81],\"scenario\":[79],\"context-oriented\":[82],\"application.\":[84]}},\"S\":[{\"Ty\":3,\"U\":\"http://www.hirschfeld.org/writings/media/AppeltauerHirschfeldRho_2008_ProgrammingSupportForContextAwareUbiquitousApplications.pdf\"},{\"Ty\":3,\"U\":\"http://www.hpi.uni-potsdam.de/hirschfeld/publications/media/AppeltauerHirschfeldRho_2008_ProgrammingSupportForContextAwareUbiquitousApplications.pdf\"},{\"Ty\":1,\"U\":\"http://yadda.icm.edu.pl/yadda/element/bwmeta1.element.ieee-000004641310\"},{\"Ty\":1,\"U\":\"http://ieeexplore.ieee.org/document/4641310/\"},{\"Ty\":1,\"U\":\"https://dl.acm.org/citation.cfm?id=1447566.1448068\"}],\"VFN\":\"Ubiquitous Computing Systems\",\"VSN\":\"UCS\",\"FP\":38,\"LP\":43,\"DOI\":\"10.1109/UBICOMM.2008.56\",\"CC\":{\"169400382\":[\"Later on, we will additionally implement services with ContextS for the Smalltalk-based Seaside [11] server.\"],\"170057163\":[\"Most context-dependent systems are developed based on context-management frameworks (e.g., [ 8 , 1]).\\u001bMobile community applications (e.g., [ 8 , 5]) allow users to share information about their mood, activities, location, and more.\\u001bSome mobile community projects provide functionality which is similar to our example (e.g., [ 8 ]).\\u001bOur infrastructure is based on IYOUIT and Android. IYOUIT [ 8 ] is a mobile community platform.\"],\"1513110806\":[\"Some AOP languages and systems come with explicit support for distributed AOP, such as AWED [9] and ReflexD [16].\"],\"1597389001\":[\"The listings presented in this paper are implemented with a second prototype, based on a generic aspect library, developed with LogicAJ1 [7].\",\"The OSGi-based aspect language CSLogicAJ [12] is an extension to LogicAJ [7].\"],\"1610570299\":[\"All terms have been coined by AspectJ [ 6 ] and have become standard.\"],\"2000090290\":[\"An open framework for Context-aware Aspects based on a reflective extension of Java [15] is proposed by [14].\"],\"2012173916\":[\"personalization and end-user development [17] or ontology-based context modeling [ 3 ].\"],\"2048440355\":[\"personalization and end-user development [17] or ontology-based context modeling [3].\"],\"2131415946\":[\"The Context Toolkit [13] influenced many of nowadays CMFs.\"],\"2150275961\":[\"Context-oriented Programming (COP) [ 4 ] enriches programming languages and execution environments with features to explicitly represent context-dependent behavior variations.\\u001bThe context-oriented Programming paradigm [ 4 ] features a new dimension of software modularization by supporting an explicit representation of context-dependent functionality.\\u001bFor a broad introduction to COP we refer to [ 4 ].\\u001bA first prototype, ContextJ* [ 4 ], has been developed previously as a proof of concept.\"],\"2150491652\":[\"Some AOP languages and systems come with explicit support for distributed AOP, such as AWED [9] and ReflexD [16].\"],\"2160377668\":[\"For a feature comparison of distributed AOP approaches, see [2].\"],\"2161291379\":[\"An open framework for Context-aware Aspects based on a reflective extension of Java [15] is proposed by [14].\"],\"2162673707\":[\"Most context-dependent systems are developed based on context-management frameworks (e.g., [8,  1 ]).\"],\"2480195817\":[\"All terms have been coined by AspectJ [6] and have become standard.\"]},\"PR\":[2150275961,2089889705,1992443356,2115607078,2144114063,1556513858,2087175184,2014881790,2143238865,2154597770,2480195817,2090764929,2061549030,2167773895,2757643432,2075642720,2074608206,2152087077,2123557157,2158731818,2150275961,2089889705,1992443356,2115607078,2144114063,1556513858,2087175184,2014881790,2143238865,2154597770,2480195817,2090764929,2061549030,2167773895,2757643432,2075642720,2074608206,2152087077,2123557157,2158731818],\"ANF\":[{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":1},{\"FN\":\"Robert\",\"LN\":\"Hirschfeld\",\"S\":2},{\"FN\":\"Tobias\",\"LN\":\"Rho\",\"S\":3}],\"BV\":\"2008 The Second International Conference on Mobile Ubiquitous Computing, Systems, Services and Technologies\",\"BT\":\"p\",\"PB\":\"IEEE\"}"},{"logprob":-20.659,"Id":1974001278,"Ty":"0","Ti":"towards concrete syntax patterns for logic based transformation rules","Pt":"1","L":"en","Y":2008,"D":"2008-11-01","CC":10,"ECC":10,"RId":[1586338668,2128466029,2100165879,2159400269,2068469682,2045765932,1625533892,2094080019,2096012235,114886242,2131755133,1532892735,1646292220,1970045008,1602100009,2031704845,2021473914,1502375563,2120125130,2115571575,1990727091,80175657,179823720,2018441537,1591896151,84182625,1516825787,40537070,180303802],"W":["concrete","logic","patterns","rules","syntax","towards","transformation"],"AA":[{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":2796791905,"DAfN":"University of Bonn","AfN":"university of bonn","AfId":135140700,"S":1},{"DAuN":"Günter Kniesel","AuN":"gunter kniesel","AuId":729669163,"DAfN":"University of Bonn","AfN":"university of bonn","AfId":135140700,"S":2}],"F":[{"DFN":"Transformation language","FN":"transformation language","FId":2776536232},{"DFN":"Theoretical computer science","FN":"theoretical computer science","FId":80444323},{"DFN":"Syntax","FN":"syntax","FId":60048249},{"DFN":"Prolog","FN":"prolog","FId":81721847},{"DFN":"Predicate functor logic","FN":"predicate functor logic","FId":2039508},{"DFN":"Logic programming","FN":"logic programming","FId":128838566},{"DFN":"Horn clause","FN":"horn clause","FId":189790780},{"DFN":"Description logic","FN":"description logic","FId":102993220},{"DFN":"Computer science","FN":"computer science","FId":41008148},{"DFN":"Autoepistemic logic","FN":"autoepistemic logic","FId":3845977}],"J":{"JN":"entcs","JId":50368787},"E":"{\"DN\":\"Towards Concrete Syntax Patterns for Logic-based Transformation Rules\",\"IA\":{\"IndexLength\":132,\"InvertedIndex\":{\"Logic\":[0],\"meta-programming\":[1],\"in\":[2,42,123],\"Prolog\":[3,55],\"is\":[4],\"a\":[5,68,80],\"powerful\":[6],\"way\":[7],\"to\":[8,26,36,58,64,111],\"express\":[9,39,65],\"program\":[10],\"analysis\":[11],\"and\":[12,20,35,38,90,127],\"transformation.\":[13],\"However,\":[14],\"its\":[15],\"use\":[16],\"can\":[17],\"be\":[18],\"difficult\":[19],\"error-prone\":[21],\"because\":[22],\"it\":[23],\"requires\":[24],\"programmers\":[25],\"know\":[27],\"the\":[28,32,50,97,103,117],\"meta-level\":[29],\"representation\":[30],\"of\":[31,44,54,67,107,119,125],\"analysed\":[33],\"language\":[34,83],\"think\":[37],\"their\":[40],\"analyses\":[41],\"terms\":[43,124],\"this\":[45,72],\"low-level\":[46],\"representation.\":[47],\"In\":[48,71],\"addition,\":[49],\"backtracking-based\":[51],\"evaluation\":[52],\"strategy\":[53],\"may\":[56],\"lead\":[57],\"subtle\":[59],\"semantic\":[60],\"problems\":[61,99],\"when\":[62],\"used\":[63],\"transformations\":[66],\"logic\":[69,108],\"database.\":[70],\"paper,\":[73],\"we\":[74],\"propose\":[75],\"an\":[76],\"alternative\":[77],\"approach,\":[78],\"GenTL,\":[79],\"generic\":[81],\"transformation\":[82,129],\"that\":[84],\"combines\":[85],\"logic-based\":[86],\"Conditional\":[87],\"Transformations\":[88],\"(CTs)\":[89],\"concrete\":[91],\"syntax\":[92],\"patterns.\":[93],\"This\":[94],\"combination\":[95],\"addresses\":[96],\"above\":[98],\"while\":[100],\"still\":[101],\"offering\":[102],\"full\":[104],\"expressive\":[105],\"power\":[106],\"meta-programming.\":[109],\"Compared\":[110],\"approaches\":[112],\"based\":[113],\"on\":[114],\"other\":[115],\"formalisms,\":[116],\"design\":[118],\"GenTL\":[120],\"offers\":[121],\"advantages\":[122],\"composability\":[126],\"easy\":[128],\"interference\":[130],\"analysis.\":[131]}},\"S\":[{\"Ty\":1,\"U\":\"https://www.sciencedirect.com/science/article/pii/S1571066108004325\"},{\"Ty\":1,\"U\":\"https://dl.acm.org/citation.cfm?id=1461266\"},{\"Ty\":0,\"U\":\"http://dl.acm.org/citation.cfm?id=1461266\"}],\"VFN\":\"Electronic Notes in Theoretical Computer Science\",\"V\":219,\"FP\":113,\"LP\":132,\"DOI\":\"10.1016/j.entcs.2008.10.038\",\"CC\":{\"40537070\":[\"[2] introduce JaTS, the Java Transformation System, which allows the definition of pattern based rewriting rules.\",\"5 [2] only describes matching of interface-level program elements.\"],\"80175657\":[\"Mens et al. show that the only other system that achieves a similar interference analysis is four orders of magnitude slower [ 15 ].\"],\"84182625\":[\"The ASF+SDF meta-environment [28,29] is a system for parser generation and program transformation.\"],\"114886242\":[\"Depending on their formal foundations these tools can be roughly classified as based on term rewriting [31,4,28,33,1], graph transformation [18], or logic [35,7].\",\"Logic meta-programming is the use of logic programming for analysing and transforming the logic representation of a program [7,35].\",\"SOUL, the Smalltalk Open Unification Language [35], enables meta-programming with logic queries and program transformations for Smalltalk, in Smalltalk.\"],\"180303802\":[\"Windeln [32] shows that the generic aspect language LogicAJ can be compiled to CTs.\",\"Due to its ability to execute CTs, JTransformer has been used as a basis for implementing the generic aspect language LogicAJ [23,32].\"],\"1502375563\":[\"Depending on their formal foundations these tools can be roughly classified as based on term rewriting [31,4,28,33,1], graph transformation [18], or logic [35,7].\",\"HATS, the High Assurance Transformation System [33,34], is a strategic term rewriting system for manipulating parse trees.\",\"Another source of inspiration could be HATS [33,34].\"],\"1516825787\":[\"HATS, the High Assurance Transformation System [33,34], is a strategic term rewriting system for manipulating parse trees.\",\"Another source of inspiration could be HATS [33,34].\"],\"1532892735\":[\"For instance, Tip, Kiezun and Bäumer [27] show that generalizing refactorings require very complex analyses which in turn need a thorough formal foundation in terms of type constraints [19].\"],\"1591896151\":[\"The logic programming language is typically a variant of Prolog [3] or some other system implementing topdown SLD resolution [16,15].\"],\"1602100009\":[\"This lets clients supply a decorator object that overrides behavior of the decorated object [25,10].\"],\"1625533892\":[\"Stratego [31,30] is a term rewriting system offering various generic term traversal strategies.\",\"The components of generic compilers are generally introduced in [30].\"],\"1646292220\":[\"Depending on their formal foundations these tools can be roughly classified as based on term rewriting [31,4,28,33,1], graph transformation [18], or logic [35,7].\",\"Logic meta-programming is the use of logic programming for analysing and transforming the logic representation of a program [7,35].\",\"The TyRuBa language [7] introduces logic meta-programming for Java.\"],\"1970045008\":[\"The logic programming language is typically a variant of Prolog [3] or some other system implementing topdown SLD resolution [16,15].\"],\"1990727091\":[\"[24] presented an extension of SOUL for matching execution flows with concrete syntax patterns.\"],\"2018441537\":[\"LogicAJ supports uniform genericity [ 8 ] by the use of meta-variables in predicates and code generation templates based on concrete syntax.\"],\"2021473914\":[\"The logic programming language is typically a variant of Prolog [3] or some other system implementing topdown SLD resolution [16,15].\"],\"2045765932\":[\"A refactoring, for instance, is just a behaviour preserving conditional transformation [14].\"],\"2068469682\":[\"Depending on their formal foundations these tools can be roughly classified as based on term rewriting [31,4,28,33,1], graph transformation [18], or logic [35,7].\"],\"2094080019\":[\"Depending on their formal foundations these tools can be roughly classified as based on term rewriting [31,4,28,33,1], graph transformation [18], or logic [35,7].\",\"The ASF+SDF meta-environment [28,29] is a system for parser generation and program transformation.\"],\"2100165879\":[\"Depending on their formal foundations these tools can be roughly classified as based on term rewriting [ 29 ,4,26,31,1], graph transformation [16], or logic [33,7].\\u001bStratego [ 29 ,28] is a term rewriting system oering various generic term traversal strategies.\"],\"2115571575\":[\"The TXL [5,4] system was originally built for rapid prototyping.\"],\"2120125130\":[\"A conditional transformation (CT) [11,12] is a pair consisting of a precondition C and a transformation T .\",\"The CTC [6] is a complete, language-independent implementation of CTs, CT sequences and the related interference analyses [12].\"],\"2128466029\":[\"Depending on their formal foundations these tools can be roughly classified as based on term rewriting [31,4,28,33,1], graph transformation [18], or logic [35,7].\",\"The TXL [5,4] system was originally built for rapid prototyping.\"],\"2131755133\":[\"For instance, JTransformer, a logic meta-programming tool for Java [13,9] represents methods by a predicate with 7 parameters.\",\"JTransformer [9,13] is a logic-based source-to-source transformation system for Java.\",\"An exception from this rule is JTransformer [9,13], a logic-based source-to-source transformation language for Java which supports logic meta-programming and conditional transformations.\"],\"2159400269\":[\"Depending on their formal foundations these tools can be roughly classified as based on term rewriting [31,4,28,33,1], graph transformation [18], or logic [35,7].\",\"MetaBorg [1] extends Stratego with domain specific language embedding, that is, the ability to manage a host language and additionally an embedded language.\"]},\"PR\":[1576311579,2346769920,2025519911,2623359354,2402452416,1517739403,1525628571,167813225,1782526664,2222926420,2794771943,2741851925,1589438871,1574891383,2429269184,1499535659,2103846976,177739690,2260835020,64425101,1576311579,2346769920,2025519911,2623359354,2402452416,1517739403,1525628571,167813225,1782526664,2222926420,2794771943,2741851925,1589438871,1574891383,2429269184,1499535659,2103846976,177739690,2260835020,64425101],\"ANF\":[{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":1},{\"FN\":\"Günter\",\"LN\":\"Kniesel\",\"S\":2}],\"BV\":\"Electronic Notes in Theoretical Computer Science\",\"BT\":\"a\",\"PB\":\"Elsevier\"}"},{"logprob":-20.829,"Id":2002568360,"Ty":"0","Ti":"dynamic contract layers","Pt":"3","L":"en","Y":2010,"D":"2010-03-22","CC":14,"ECC":14,"RId":[2138363365,2480195817,2143238865,2161825580,2052363833,2150275961,2886283850,2125682153,1555946950,1574060188,2111706174,1992443356,1531869376,2090496119,2144114063,166270156,61997153,1491095550,2105142318,2087175184,2165121897,1601712140,956539890,1556513858,2172169742,1584704555,2803343605,221784231,2164859807,2146987093,2118399307],"W":["contract","dynamic","layers"],"AA":[{"DAuN":"Robert Hirschfeld","AuN":"robert hirschfeld","AuId":2154319088,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":1},{"DAuN":"Michael Perscheid","AuN":"michael perscheid","AuId":698431335,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":2},{"DAuN":"Christian Schubert","AuN":"christian schubert","AuId":2493869840,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":3},{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":135591984,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":4}],"F":[{"DFN":"dBc","FN":"dbc","FId":193523891},{"DFN":"Thread (computing)","FN":"thread","FId":138101251},{"DFN":"Real-time computing","FN":"real time computing","FId":79403827},{"DFN":"Python (programming language)","FN":"python","FId":519991488},{"DFN":"Implementation","FN":"implementation","FId":26713055},{"DFN":"Function composition (computer science)","FN":"function composition","FId":104637301},{"DFN":"Enforcement","FN":"enforcement","FId":2779777834},{"DFN":"Design by contract","FN":"design by contract","FId":80291951},{"DFN":"Contract management","FN":"contract management","FId":55451941},{"DFN":"Computer science","FN":"computer science","FId":41008148}],"C":{"CN":"sac","CId":2754781246},"E":"{\"DN\":\"Dynamic contract layers\",\"IA\":{\"IndexLength\":170,\"InvertedIndex\":{\"Design\":[0],\"by\":[1,116,161],\"Contract\":[2,45],\"(DBC)\":[4],\"is\":[5,143],\"a\":[6,35,117],\"programming\":[7,155],\"technique\":[8],\"to\":[9,26,70,82,165],\"separate\":[10],\"contract\":[11,97,105,131],\"enforcement\":[12,46,132],\"from\":[13,43,110],\"application\":[14],\"code.\":[15],\"DBC\":[16,40,115],\"provides\":[17],\"information\":[18],\"about\":[19],\"the\":[20,29,71,83,153,166],\"applicability\":[21],\"of\":[22,34,74,126,141],\"methods\":[23],\"and\":[24,61,76,103,124,129],\"helps\":[25],\"narrow\":[27],\"down\":[28],\"search\":[30],\"space\":[31],\"in\":[32,65],\"case\":[33],\"software\":[36],\"failure.\":[37],\"However,\":[38],\"most\":[39],\"implementations\":[41],\"suffer\":[42],\"inflexibility:\":[44],\"can\":[47],\"only\":[48],\"be\":[49,63,79],\"activated\":[50],\"or\":[51,55],\"deactivated\":[52],\"at\":[53,133],\"compile-time\":[54],\"start-up,\":[56],\"contracts\":[57,77,164],\"are\":[58],\"checked\":[59],\"globally\":[60],\"cannot\":[62,78],\"restricted\":[64],\"their\":[66],\"scope\":[67],\"such\":[68,127],\"as\":[69],\"current\":[72],\"thread\":[73],\"execution,\":[75],\"grouped\":[80],\"according\":[81],\"concerns\":[84],\"they\":[85],\"relate\":[86],\"to.\":[87],\"In\":[90],\"this\":[91],\"paper,\":[92],\"we\":[93,113],\"present\":[94],\"dynamic\":[96],\"layers\":[98],\"(DCL)\":[99],\"for\":[101,120,152],\"fine-grained\":[102],\"flexible\":[104],\"management.\":[106],\"Based\":[107],\"on\":[108],\"ideas\":[109],\"context-oriented\":[111],\"programming,\":[112],\"extend\":[114],\"grouping\":[118],\"mechanism\":[119],\"contracts,\":[121],\"thread-local\":[122],\"activation\":[123],\"deactivation\":[125],\"groups,\":[128],\"selective\":[130],\"run-time.\":[134],\"PyDCL\":[136,163],\",\":[137,148],\"our\":[138,149,159],\"proof-of-concept\":[139],\"implementation\":[140],\"DCL,\":[142],\"built\":[144],\"onto\":[145],\"ContextPy\":[147],\"COP\":[150],\"extension\":[151],\"Python\":[154],\"language.\":[156],\"We\":[157],\"evaluate\":[158],\"approach\":[160],\"applying\":[162],\"Moin-Moin\":[167],\"Wiki\":[168],\"framework.\":[169]}},\"S\":[{\"Ty\":3,\"U\":\"http://www.hirschfeld.org/writings/media/HirschfeldPerscheidSchubertAppeltauer_2010_DynamicContractLayers_AcmDL.pdf\"},{\"Ty\":1,\"U\":\"https://doi.acm.org/10.1145/1774088.1774546\"},{\"Ty\":1,\"U\":\"http://dblp.uni-trier.de/db/conf/sac/sac2010.html#HirschfeldPSA10\"},{\"Ty\":1,\"U\":\"https://dl.acm.org/ft_gateway.cfm?id=1774546&type=pdf\"}],\"VFN\":\"ACM Symposium on Applied Computing\",\"VSN\":\"SAC\",\"FP\":2169,\"LP\":2175,\"DOI\":\"10.1145/1774088.1774546\",\"CC\":{\"61997153\":[\"PyDCL is our implementation of DCL in and for the Python programming language [28].\"],\"166270156\":[\"iContract by Kramer [20] uses structured comments (like [25, 31]) for specifying contracts and provides a preprocessor that instruments the original source code with contract checks.\"],\"956539890\":[\"Some AOP languages, such as CaesarJ [3] and AspectS [12] overcome this limitation and provide dynamic aspect weaving, though they lack in supporting annotationbased pointcuts.\"],\"1491095550\":[\"Some AOP languages, such as CaesarJ [3] and AspectS [12] overcome this limitation and provide dynamic aspect weaving, though they lack in supporting annotationbased pointcuts.\"],\"1555946950\":[\"The ideas of DBC [21] and their first incarnation in the Eiffel programming language [22] have contributed to software engineering for almost two decades now [27].\"],\"1556513858\":[\"So far, COP has been implemented for several languages such as Lisp [5], Smalltalk [13], Python [29], 1 employerLayer = layer(\\\"Employer\\\")\"],\"1574060188\":[\"In future work, we are interested in exploring inductive debugging concepts in combination with automatically generated contracts [32].\",\"Future work will be concerned with inductive debugging techniques [32].\"],\"1584704555\":[\"In Duncan and Hölzle’s Handshake [6] contracts are read from a separate file with a Java-like syntax.\"],\"1992443356\":[\"So far, COP has been implemented for several languages such as Lisp [5], Smalltalk [13], Python [29], 1 employerLayer = layer(\\\"Employer\\\")\"],\"2052363833\":[\"With Design by Contract (DBC [16, 21]) programmers can separate the specification of pre- and postconditions and invariants from their application code to improve code comprehensibility and quality.\",\"The ideas of DBC [21] and their first incarnation in the Eiffel programming language [22] have contributed to software engineering for almost two decades now [27].\",\"Besides the original DBC implementation in Eiffel [21], we can find DBC extensions to several other programming languages.\"],\"2087175184\":[\"So far, COP has been implemented for several languages such as Lisp [5], Smalltalk [13], Python [29], 1 employerLayer = layer(\\\"Employer\\\")\",\"PyContext [29] is another COP library in Python.\"],\"2090496119\":[\"With Design by Contract (DBC [16, 21]) programmers can separate the specification of pre- and postconditions and invariants from their application code to improve code comprehensibility and quality.\"],\"2111706174\":[\"The roots of DBC can be traced back to the work of Floyd [8] and Hoare [15].\"],\"2118399307\":[\"The ideas of DBC [21] and their first incarnation in the Eiffel programming language [22] have contributed to software engineering for almost two decades now [27].\"],\"2125682153\":[\"For instance, grouping contracts related to specific requirements is almost impossible since the implementation of most of the requirements are spread over several classes and so cannot be related to a single one [7, 9].\"],\"2143238865\":[\"Aspect-oriented programming [19] (AOP) provides language abstractions to encapsulate crosscutting concerns, thus it is conceptually related to COP.\"],\"2144114063\":[\"An overview of most of them is provided in [1].\",\"It supports the layer-in-class approach [1] and with that allows developers to define their partial methods within the scope of the actual classes these methods are contributing to.\"],\"2146987093\":[\"Guerreiro [10] implements contracts for C++.\"],\"2150275961\":[\"In this paper, we present dynamic contract layers (DCL), which augment the flexibility of state-of-theart DBC approaches by combining them with ideas from context-oriented programming (COP [14]).\",\"It turns out that context-oriented programming [14] (COP) is an ideal base for our extension to DBC.\",\"A broader introduction to COP is provided in [14].\"],\"2161825580\":[\"During the evaluation of an assertion all subsequent method calls must be executed without any evaluation [23].\"],\"2164859807\":[\"Today, there are at least three freely available implementations of DBC in Python: Design by Contract by Plösch [25], ContractPy [31], and PyDBC [4].\",\"iContract by Kramer [20] uses structured comments (like [25, 31]) for specifying contracts and provides a preprocessor that instruments the original source code with contract checks.\"],\"2165121897\":[\"Later work by Parnas [24] already\"],\"2172169742\":[\"Ruby [26], and Java [2].\"],\"2480195817\":[\"Contract4J [30] is an AspectJ [18] based tool that supports classic DBC.\"],\"2803343605\":[\"For instance, grouping contracts related to specific requirements is almost impossible since the implementation of most of the requirements are spread over several classes and so cannot be related to a single one [7, 9].\",\"Feature analysis [9] is a research area that provides an answer to the question which methods are concerned in which features.\"]},\"PR\":[1992443356,1556513858,2065646798,2087175184,2143238865,2144114063,2150275961,2286558606,1572825593,2014881790,2075642720,2115607078,34876640,260230765,2136563725,2022299558,2593584386,778258840,2142650158,2135583192,1992443356,1556513858,2065646798,2087175184,2143238865,2144114063,2150275961,2286558606,1572825593,2014881790,2075642720,2115607078,34876640,260230765,2136563725,2022299558,2593584386,778258840,2142650158,2135583192],\"ANF\":[{\"FN\":\"Robert\",\"LN\":\"Hirschfeld\",\"S\":1},{\"FN\":\"Michael\",\"LN\":\"Perscheid\",\"S\":2},{\"FN\":\"Christian\",\"LN\":\"Schubert\",\"S\":3},{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":4}],\"BV\":\"Proceedings of the 2010 ACM Symposium on Applied Computing\",\"BT\":\"p\",\"PB\":\"ACM\"}"},{"logprob":-20.84,"Id":1965245408,"Ty":"0","Ti":"columnar objects improving the performance of analytical applications","Pt":"3","L":"en","Y":2015,"D":"2015-10-21","CC":4,"ECC":4,"RId":[1523201922,1770006921,1979300931,1977330283,2130642985,2172147300,1993335798,11774449,2058213389,2295562782,2036862988,1506075075,2058639022,1998416211,137313736,1597864774,2027416917,2084819966,70887012,2405929300],"W":["analytical","applications","columnar","improving","objects","performance"],"AA":[{"DAuN":"Toni Mattis","AuN":"toni mattis","AuId":2229898846,"DAfN":"HPI, Germany","S":1},{"DAuN":"Johannes Henning","AuN":"johannes henning","AuId":2223724161,"DAfN":"HPI, Germany","S":2},{"DAuN":"Patrick Rein","AuN":"patrick rein","AuId":2229220081,"DAfN":"HPI, Germany","S":3},{"DAuN":"Robert Hirschfeld","AuN":"robert hirschfeld","AuId":2154319088,"DAfN":"HPI, Germany","S":4},{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":135591984,"DAfN":"SAP, Germany","S":5}],"F":[{"DFN":"Tree traversal","FN":"tree traversal","FId":140745168},{"DFN":"Tracing just-in-time compilation","FN":"tracing just in time compilation","FId":50450317},{"DFN":"Theoretical computer science","FN":"theoretical computer science","FId":80444323},{"DFN":"Python (programming language)","FN":"python","FId":519991488},{"DFN":"Leverage (finance)","FN":"leverage","FId":81931697},{"DFN":"Just-in-time compilation","FN":"just in time compilation","FId":76782552},{"DFN":"Interpreter","FN":"interpreter","FId":122783720},{"DFN":"Computer science","FN":"computer science","FId":41008148},{"DFN":"Computer data storage","FN":"computer data storage","FId":194739806},{"DFN":"Business logic","FN":"business logic","FId":146222976}],"C":{"CN":"onward","CId":2759899939},"E":"{\"DN\":\"Columnar objects: improving the performance of analytical applications\",\"IA\":{\"IndexLength\":170,\"InvertedIndex\":{\"Growing\":[0],\"volumes\":[1],\"of\":[2,74,88,102],\"data\":[3,27,49],\"increase\":[4],\"the\":[5,61,71,103,150,162],\"demand\":[6],\"to\":[7,13,43,56,67,81,85,99,110,139,144],\"use\":[8],\"it\":[9],\"in\":[10,90,117],\"analytical\":[11,44,131],\"applications\":[12],\"make\":[14],\"informed\":[15],\"decisions.\":[16],\"Unfortunately,\":[17],\"object-oriented\":[18,83,135,166],\"runtimes\":[19,84,167],\"experience\":[20],\"performance\":[21],\"problems\":[22,30,159],\"when\":[23],\"dealing\":[24],\"with\":[25,123],\"large\":[26],\"volumes.\":[28],\"Similar\":[29],\"have\":[31],\"been\":[32],\"addressed\":[33],\"by\":[34,106],\"column-oriented\":[35,92],\"in-memory\":[36],\"databases,\":[37],\"whose\":[38],\"memory\":[39,93],\"layout\":[40,94,105],\"is\":[41,65],\"tailored\":[42],\"workloads.\":[45],\"As\":[46],\"a\":[47,58,91,97,119,124],\"result,\":[48],\"storage\":[50],\"and\":[51,95,168],\"processing\":[52],\"are\":[53,76,137],\"often\":[54],\"delegated\":[55],\"such\":[57],\"database.\":[59],\"However,\":[60],\"more\":[62,72],\"domain\":[63],\"logic\":[64],\"moved\":[66],\"this\":[68],\"separate\":[69],\"system,\":[70],\"benefits\":[73],\"object-orientation\":[75],\"lost.\":[77],\"We\":[78,113],\"propose\":[79],\"modifications\":[80],\"dynamic\":[82],\"store\":[86],\"collections\":[87],\"objects\":[89],\"leverage\":[96],\"jit\":[98],\"take\":[100],\"advantage\":[101],\"adjusted\":[104],\"mapping\":[107],\"object\":[108],\"traversal\":[109],\"array\":[111],\"operations.\":[112],\"implemented\":[114],\"our\":[115,145],\"concept\":[116],\"PyPy,\":[118],\"Python\":[120],\"interpreter\":[121],\"equipped\":[122],\"tracing\":[125],\"jit.\":[126],\"Finally,\":[127],\"we\":[128],\"show\":[129],\"that\":[130],\"algorithms,\":[132],\"expressed\":[133],\"through\":[134],\"code,\":[136],\"up\":[138],\"three\":[140],\"times\":[141],\"faster\":[142],\"due\":[143],\"optimizations,\":[146],\"without\":[147],\"substantially\":[148],\"impairing\":[149],\"paradigm.\":[151],\"Hopefully,\":[152],\"extending\":[153],\"these\":[154],\"concepts\":[155],\"will\":[156],\"mitigate\":[157],\"some\":[158],\"originating\":[160],\"from\":[161],\"paradigm\":[163],\"mismatch\":[164],\"between\":[165],\"databases.\":[169]}},\"S\":[{\"Ty\":3,\"U\":\"http://www.hirschfeld.org/writings/media/MattisHenningReinHirschfeldAppeltauer_2015_ColumnarObjectsImprovingThePerformanceOfAnalyticalApplications_AuthorsVersion.pdf\"},{\"Ty\":1,\"U\":\"http://dblp.uni-trier.de/db/conf/oopsla/onward2015.html#MattisHRHA15\"},{\"Ty\":1,\"U\":\"https://dl.acm.org/citation.cfm?id=2814230\"}],\"VFN\":\"SIGPLAN symposium on New ideas, new paradigms, and reflections on programming and software\",\"VSN\":\"Onward!\",\"FP\":197,\"LP\":210,\"DOI\":\"10.1145/2814228.2814230\",\"CC\":{\"70887012\":[\"This idea has been explored before in compiler-based transformations to speed up simulations in Java [17] and Kedama [18] (see sections 6.\",\"Noth [17] proposed a modification to the Java language introducing the exploded keyword.\"],\"137313736\":[\"One example for a columnar database based on the described concepts is SanssouciDB, which influenced the design of SAP HANA [19, 21].\"],\"1597864774\":[\"Elo-Ranking Given a set of competing players and a large amount of data recording which player or strategy outperformed or defeated an opponent, the Elo rating [7] puts a rating on each competitor, quantifying its overall performance.\"],\"1770006921\":[\"1A notable exception are object tables known from Smalltalk, which implement a location-independent notion of object identity [8] 3.\"],\"1977330283\":[\"However, most analytical algorithms only use a subset of these columns [19, 20].\"],\"1979300931\":[\"The estimator is mathematically defined and has a straightforward implementation as a product [11].\"],\"1993335798\":[\"The resulting trace undergoes a register allocation step and is compiled to architecture-specific native code [4].\",\"Program design that optimizes for a meta-tracing JIT is likely transferable to other language implementations based on it [4].\"],\"1998416211\":[\"The most important optimization we will address in this paper is the removal of object allocations inside a trace [5].\"],\"2027416917\":[\"The OOPAL model [15] aims to extend the object-oriented model with concepts from array programming, as found for example in APL.\"],\"2036862988\":[\"The GemStone/S system [13] is an object database which is capable of running a full application.\"],\"2058213389\":[\"1 PyPy is a meta-traced Python interpreter build in RPython [22] 2.\"],\"2058639022\":[\"Dynamic languages usually link an attribute name to its offset via a structure called map [3, 6, 23] or hidden class [9] referenced by the object header and shared between objects with the same structure.\"],\"2130642985\":[\"1) [1].\"],\"2172147300\":[\"It is integrated into the eToys system, which itself is build on top of Squeak [10], a Smalltalk system.\"],\"2295562782\":[\"References to an object are implemented as pointers to the object’s memory [12] 1.\",\"2 also known as surrogate in the context of object identity [12] We also introduce a class ID column to record the most specific subclass responsible for a particular column offset and to guarantee correct polymorphic message dispatch in co-variant collections and attributes.\"],\"2405929300\":[\"This idea has been explored before in compiler-based transformations to speed up simulations in Java [17] and Kedama [18] (see sections 6.\",\"The Kedama [18] educational parallel programming system allows users to program “turtles”, a sort of agents that interact with their environment, organized as a grid.\"]},\"PR\":[2256532437,2255712816,2592205526,2899200806,2742163642,2106771621,2892366630,2414240756,42977290,2058829268,2786320458,1589893694,48121001,2749944597,2674334413,2291177998,2227555601,2041701365,2769729463,2242016257,2256532437,2255712816,2592205526,2899200806,2742163642,2106771621,2892366630,2414240756,42977290,2058829268,2786320458,1589893694,48121001,2749944597,2674334413,2291177998,2227555601,2041701365,2769729463,2242016257],\"ANF\":[{\"FN\":\"Toni\",\"LN\":\"Mattis\",\"S\":1},{\"FN\":\"Johannes\",\"LN\":\"Henning\",\"S\":2},{\"FN\":\"Patrick\",\"LN\":\"Rein\",\"S\":3},{\"FN\":\"Robert\",\"LN\":\"Hirschfeld\",\"S\":4},{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":5}],\"BV\":\"2015 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software (Onward!)\",\"BT\":\"p\",\"PB\":\"ACM\"}"},{"logprob":-20.886,"Id":2006015625,"Ty":"0","Ti":"context oriented programming for mobile devices jcop on android","Pt":"0","L":"en","Y":2011,"D":"2011-07-25","CC":7,"ECC":7,"RId":[2168867823,2150275961,2168397291,2060640309,2089889705,2154597770,175922506,2090764929,2115899208],"W":["android","context","devices","jcop","mobile","oriented","programming"],"AA":[{"DAuN":"Christopher Schuster","AuN":"christopher schuster","AuId":2225215592,"DAfN":"University of California, Davis","AfN":"university of california davis","AfId":84218800,"S":1},{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":135591984,"DAfN":"Software Architecture Group, Hasso-Plattner-Institut, Germany","S":2},{"DAuN":"Robert Hirschfeld","AuN":"robert hirschfeld","AuId":2154319088,"DAfN":"Software Architecture Group, Hasso-Plattner-Institut, Germany","S":3}],"F":[{"DFN":"Theoretical computer science","FN":"theoretical computer science","FId":80444323},{"DFN":"Semantics","FN":"semantics","FId":124246873},{"DFN":"Proof of concept","FN":"proof of concept","FId":124978682},{"DFN":"Modularity","FN":"modularity","FId":100648641},{"DFN":"Mobile device","FN":"mobile device","FId":186967261},{"DFN":"Mobile computing","FN":"mobile computing","FId":144543869},{"DFN":"Control flow","FN":"control flow","FId":160191386},{"DFN":"Computer science","FN":"computer science","FId":41008148},{"DFN":"Compiler","FN":"compiler","FId":169590947},{"DFN":"Android (operating system)","FN":"android","FId":557433098}],"E":"{\"DN\":\"Context-oriented programming for mobile devices: JCop on Android\",\"IA\":{\"IndexLength\":145,\"InvertedIndex\":{\"The\":[0],\"behavior\":[1,31,49],\"of\":[2,47,106,129],\"mobile\":[3,19,59,133],\"applications\":[4,60,108],\"is\":[5,61],\"particularly\":[6],\"affected\":[7],\"by\":[8,43,64,72,88],\"their\":[9],\"execution\":[10],\"context,\":[11],\"such\":[12],\"as\":[13],\"location\":[14],\"and\":[15,67,74,119,138],\"state\":[16],\"a\":[17,38,84,130],\"the\":[18,80,104,113,121,126],\"device.\":[20],\"Among\":[21],\"other\":[22],\"approaches,\":[23],\"context-oriented\":[24],\"programming\":[25],\"can\":[26],\"help\":[27],\"to\":[28,37,103],\"achieve\":[29],\"context-dependent\":[30],\"without\":[32],\"sacrificing\":[33],\"modularity\":[34],\"or\":[35,41],\"adhering\":[36],\"certain\":[39],\"framework\":[40],\"library\":[42],\"enabling\":[44],\"fine-grained\":[45],\"adaptation\":[46,90],\"default\":[48],\"per\":[50],\"control-flow.\":[51],\"However,\":[54],\"context\":[55],\"information\":[56],\"relevant\":[57],\"for\":[58,109,116],\"mostly\":[62],\"defined\":[63],\"external\":[65],\"events\":[66],\"sensor\":[68],\"data\":[69],\"rather\":[70],\"than\":[71],\"code\":[73],\"control\":[75],\"flow.\":[76],\"To\":[77],\"accommodate\":[78],\"this,\":[79],\"JCop\":[81,102],\"language\":[82,114],\"provides\":[83],\"more\":[85],\"declarative\":[86],\"approach\":[87,137],\"pointcut-like\":[89],\"rules.\":[91],\"In\":[94],\"this\":[95],\"paper,\":[96],\"we\":[97,100,111,124],\"explain\":[98],\"how\":[99],\"applied\":[101],\"development\":[105],\"Android\":[107],\"which\":[110],\"extended\":[112],\"semantics\":[115],\"static\":[117],\"contexts\":[118],\"modified\":[120],\"compiler.\":[122],\"Additionally,\":[123],\"outline\":[125],\"successful\":[127],\"implementation\":[128],\"simple,\":[131],\"proof-of-concept\":[132],\"application\":[134],\"using\":[135],\"our\":[136],\"report\":[139],\"on\":[140],\"promising\":[141],\"early\":[142],\"evaluation\":[143],\"results.\":[144]}},\"S\":[{\"Ty\":3,\"U\":\"http://www.hpi.uni-potsdam.de/hirschfeld/publications/media/SchusterAppeltauerHirschfeld_2011_ContextOrientedProgrammingForMobileDevicesJCopOnAndroid_AcmDL.pdf\"},{\"Ty\":3,\"U\":\"http://www.hirschfeld.org/writings/media/SchusterAppeltauerHirschfeld_2011_ContextOrientedProgrammingForMobileDevicesJCopOnAndroid_AcmDL.pdf\"},{\"Ty\":1,\"U\":\"https://dl.acm.org/citation.cfm?doid=2068736.2068741\"}],\"VFN\":\"Proceedings of the 3rd International Workshop on Context-Oriented Programming\",\"FP\":5,\"DOI\":\"10.1145/2068736.2068741\",\"CC\":{\"175922506\":[\"Therefore, we applied the Java-based JCop language [2] to the Android system.\",\"The JCop language [2] extends Java with COP constructs.\",\"A thorough presentation of JCop can be found in previous work [2].\"],\"2060640309\":[\"The EventCJ [9] language is closely related to JCop.\"],\"2090764929\":[\"Du and Wang presented a solution [7] that also helps the programmer with context-aware code on mobile devices.\"],\"2115899208\":[\"Core COP functionality has been implemented by the language prototypes ContextJ* [8] and ContextLogicAJ [3] and by the ContextJ [1] extension that supports language constructs and concrete syntax for layer declaration within classes and explicit layer composition.\"],\"2150275961\":[\"Core COP functionality has been implemented by the language prototypes ContextJ* [8] and ContextLogicAJ [3] and by the ContextJ [1] extension that supports language constructs and concrete syntax for layer declaration within classes and explicit layer composition.\"],\"2154597770\":[\"The first ideas about a COP extension to Java have been presented [6] to improve the accessibility of the ContextL code discussed in that paper.\"],\"2168397291\":[\"Solutions like CARMEN [5] on the other side, are using policies and profiles to change the behavior of an application depending on the context.\"],\"2168867823\":[\"Aura [4] is more task-oriented and does not provide context-awareness for just a few lines of code.\"]},\"PR\":[2078700749,2360850817,1979170223,2158046992,2148598061,1885607155,2294648988,1506118547,2016524933,1601065112,1991573380,2171162929,2681207598,2085523245,2144826721,2065806868,2028018597,122347058,16250742,2409574047,2078700749,2360850817,1979170223,2158046992,2148598061,1885607155,2294648988,1506118547,2016524933,1601065112,1991573380,2171162929,2681207598,2085523245,2144826721,2065806868,2028018597,122347058,16250742,2409574047],\"ANF\":[{\"FN\":\"Christopher\",\"LN\":\"Schuster\",\"S\":1},{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":2},{\"FN\":\"Robert\",\"LN\":\"Hirschfeld\",\"S\":3}],\"BV\":\"Proceedings of the 3rd International Workshop on Context-Oriented Programming\",\"BT\":\"p\",\"PB\":\"ACM\"}"},{"logprob":-21.03,"Id":1990628165,"Ty":"0","Ti":"layered method dispatch with invokedynamic an implementation study","Pt":"0","L":"en","Y":2010,"D":"2010-06-22","CC":10,"ECC":10,"RId":[2150275961,2144114063,2118300983,2089889705,2086014732,1491095550,1556513858,2172169742,2014881790],"W":["dispatch","implementation","invokedynamic","layered"],"AA":[{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":135591984,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":1},{"DAuN":"Michael Haupt","AuN":"michael haupt","AuId":2146662369,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":2},{"DAuN":"Robert Hirschfeld","AuN":"robert hirschfeld","AuId":2154319088,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":3}],"F":[{"DFN":"strictfp","FN":"strictfp","FId":174954855},{"DFN":"Virtual machine","FN":"virtual machine","FId":25344961},{"DFN":"Spite","FN":"spite","FId":181836184},{"DFN":"Real time Java","FN":"real time java","FId":132106392},{"DFN":"Programming language","FN":"programming language","FId":199360897},{"DFN":"Java concurrency","FN":"java concurrency","FId":181907185},{"DFN":"Java","FN":"java","FId":548217200},{"DFN":"Computer science","FN":"computer science","FId":41008148},{"DFN":"Compiler","FN":"compiler","FId":169590947},{"DFN":"Bytecode","FN":"bytecode","FId":2779818221}],"E":"{\"DN\":\"Layered method dispatch with INVOKEDYNAMIC: an implementation study\",\"IA\":{\"IndexLength\":79,\"InvertedIndex\":{\"This\":[0],\"paper\":[1],\"describes\":[2],\"an\":[3],\"implementation\":[4,38,64,76],\"study\":[5],\"in\":[6,65],\"which\":[7],\"we\":[8],\"use\":[9],\"the\":[10,18,25,36,43,57,66,73],\"upcoming\":[11],\"INVOKEDYNAMIC\":[12],\"bytecode\":[13],\"instruction---to\":[14],\"be\":[15],\"supported\":[16],\"by\":[17],\"standard\":[19],\"Java\":[20,28,67],\"virtual\":[21,68],\"machine\":[22],\"starting\":[23],\"with\":[24,40],\"release\":[26],\"of\":[27,42,51,56,59,72],\"7---to\":[29],\"implement\":[30],\"layered\":[31],\"method\":[32],\"dispatch.\":[33],\"We\":[34],\"compare\":[35],\"resulting\":[37],\"approach\":[39],\"that\":[41],\"existing\":[44],\"JCop\":[45,75],\"compiler,\":[46],\"and\":[47],\"present\":[48],\"preliminary\":[49],\"results\":[50],\"comparative\":[52],\"benchmarks.\":[53],\"In\":[54],\"spite\":[55],\"as\":[58],\"now\":[60],\"not\":[61],\"optimized\":[62],\"INVOKEDYAMIC\":[63],\"machine,\":[69],\"performance\":[70],\"characteristics\":[71],\"INVOKEDYNAMIC-based\":[74],\"are\":[77],\"promising.\":[78]}},\"S\":[{\"Ty\":1,\"U\":\"https://dl.acm.org/citation.cfm?id=1930021.1930025\"}],\"VFN\":\"Proceedings of the 2nd International Workshop on Context-Oriented Programming\",\"FP\":4,\"DOI\":\"10.1145/1930021.1930025\",\"CC\":{\"1491095550\":[\"ContextS is based on the dynamic aspect language AspectS [ 6 ], which manages dynamic recomposition.\"],\"1556513858\":[\"COP extensions related to our ID approach make use of their host languages’ support for dynamic delegation, such as ContextS [ 7 ] and cj/delMDSOC [11], much like ID does for Java.\"],\"2014881790\":[\"COP extensions related to our ID approach make use of their host languages’ support for dynamic delegation, such as ContextS [7] and cj/delMDSOC [ 11 ], much like ID does for Java.\"],\"2086014732\":[\"The upcoming Java 7 release includes a powerful extension to the language’s meta programming facilities: the INVOKEDYNAMIC (henceforth abbreviated “ID”) instruction 1 [ 10 ].\"],\"2089889705\":[\"Some language constructs, such as top-level layer declarations and layered fields, are first transformed into an intermediate aspect representation that is then woven into the byte code classes, see Figure 3. In the following, we only refer to core COP features that have been developed in our previous work on ContextJ [ 3 ].\"],\"2118300983\":[\"JCop [1], our current context-oriented Java language extension is implemented as a JastAdd [ 5 ] compiler extension, offering a convenient syntax extension and generating plain Java bytecode.\"],\"2144114063\":[\"In previous work [ 2 ], we conducted several microbenchmarks to measure possible performance decreases of our implementation of layer-aware method lookup.\\u001bCOP are performance issues in previous implementations, as discussed along micro-benchmarks in previous work [ 2 ].\\u001bFor more details on this benchmark, see [ 2 ].\\u001bSeveral other COP languages also implement a layer-based recomposition that taking place at composition time, where method references are re-linked at any occurrence of with and without [ 2 ].\"],\"2150275961\":[\"We show both implementations along the classic COP example of a class Person that provides a layered method toString for which a partial method is defined in the layer Address [ 8 ].\"],\"2172169742\":[\"In previous work, we did the latter for the Java programming language and developed two extensions with dedicated COP language constructs [ 4 , 1].\"]},\"PR\":[55389199,2837098351,252190987,2828477504,2391215804,2278018869,2736703304,2166864541,2020191041,1947486167,2334289172,2147249227,2152619630,183374640,2083874451,1502238044,2120003701,1978875190,2480195817,2160581408,55389199,2837098351,252190987,2828477504,2391215804,2278018869,2736703304,2166864541,2020191041,1947486167,2334289172,2147249227,2152619630,183374640,2083874451,1502238044,2120003701,1978875190,2480195817,2160581408],\"ANF\":[{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":1},{\"FN\":\"Michael\",\"LN\":\"Haupt\",\"S\":2},{\"FN\":\"Robert\",\"LN\":\"Hirschfeld\",\"S\":3}],\"BV\":\"Proceedings of the 2nd International Workshop on Context-Oriented Programming\",\"BT\":\"p\",\"PB\":\"ACM\"}"},{"logprob":-21.087,"Id":179823720,"Ty":"0","Ti":"code analyses for refactoring by source code patterns and logical queries","Pt":"3","Y":2007,"D":"2007-01-01","CC":6,"ECC":6,"RId":[2113628515,2045765932,2096012235,114886242,2131755133,1646292220,53517318,1974001278,2120125130,1498700995],"W":["analyses","code","logical","patterns","queries","refactoring","source"],"AA":[{"DAuN":"Daniel Speicher","AuN":"daniel speicher","AuId":1968284350,"DAfN":"University of Bonn","AfN":"university of bonn","AfId":135140700,"S":1},{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":2796791905,"DAfN":"University of Bonn","AfN":"university of bonn","AfId":135140700,"S":2},{"DAuN":"Günter Kniesel","AuN":"gunter kniesel","AuId":729669163,"DAfN":"University of Bonn","AfN":"university of bonn","AfId":135140700,"S":3}],"F":[{"DFN":"Unreachable code","FN":"unreachable code","FId":50951305},{"DFN":"Theoretical computer science","FN":"theoretical computer science","FId":80444323},{"DFN":"Static program analysis","FN":"static program analysis","FId":137287247},{"DFN":"Source code","FN":"source code","FId":43126263},{"DFN":"Programming language","FN":"programming language","FId":199360897},{"DFN":"Dead code","FN":"dead code","FId":47434764},{"DFN":"Computer science","FN":"computer science","FId":41008148},{"DFN":"Code word","FN":"code word","FId":153207627},{"DFN":"Code refactoring","FN":"code refactoring","FId":152752567},{"DFN":"Code generation","FN":"code generation","FId":133162039},{"DFN":"Code bloat","FN":"code bloat","FId":126471770}],"C":{"CN":"ecoop","CId":1177184315},"E":"{\"DN\":\"Code Analyses for Refactoring by Source Code Patterns and Logical Queries.\",\"IA\":{\"IndexLength\":125,\"InvertedIndex\":{\"Preconditions\":[0],\"of\":[1,20,22,36,48,66,73,81,89,113],\"refactorings\":[2],\"often\":[3],\"comprise\":[4],\"complex\":[5],\"analyses\":[6,94],\"that\":[7,115],\"require\":[8],\"a\":[9,46,50,74,110],\"solid\":[10],\"formal\":[11,123],\"basis.\":[12],\"The\":[13],\"bigger\":[14],\"the\":[15,18,23,26,30,32,37,58,70,87,93,122],\"gap\":[16],\"between\":[17],\"level\":[19],\"abstraction\":[21],\"formalism\":[24],\"and\":[25,34,53,64,99],\"actual\":[27],\"implementation\":[28,107],\"is,\":[29],\"harder\":[31],\"coding\":[33],\"maintenance\":[35],\"analysis\":[38,52],\"will\":[39],\"be.\":[40],\"In\":[41],\"this\":[42],\"paper\":[43],\"we\":[44],\"describe\":[45],\"subset\":[47],\"GenTL,\":[49],\"generic\":[51],\"transformation\":[54],\"language.\":[55],\"It\":[56],\"balances\":[57],\"need\":[59],\"for\":[60,101],\"expressiveness,\":[61],\"high\":[62],\"abstractness\":[63],\"ease\":[65],\"use\":[67],\"by\":[68,91,96],\"combining\":[69],\"full\":[71],\"power\":[72],\"logic\":[75],\"language\":[76],\"with\":[77],\"easily\":[78],\"accessible\":[79],\"definitions\":[80],\"source\":[82],\"code\":[83,114],\"patterns.\":[84],\"We\":[85],\"demonstrate\":[86],\"advantages\":[88],\"GenTL\":[90],\"implementing\":[92],\"developed\":[95],\"Tip,\":[97],\"Kiezun\":[98],\"Baumer\":[100],\"generalizing\":[102],\"type\":[103],\"constraints\":[104],\"[11].\":[105],\"Our\":[106],\"needs\":[108],\"just\":[109],\"few\":[111],\"lines\":[112],\"can\":[116],\"be\":[117],\"directly\":[118],\"traced\":[119],\"back\":[120],\"to\":[121],\"rules.\":[124]}},\"S\":[{\"Ty\":1,\"U\":\"http://dblp.uni-trier.de/db/conf/ecoop/wrt2007.html#SpeicherAK07\"}],\"VFN\":\"European Conference on Object-Oriented Programming\",\"VSN\":\"ECOOP\",\"FP\":17,\"LP\":20,\"CC\":{\"114886242\":[\"Part of this problem has been addressed by various approaches to logic meta-programming [4], [13].\"],\"1646292220\":[\"Part of this problem has been addressed by various approaches to logic meta-programming [4], [13].\"],\"1974001278\":[\"This mapping is described in [1].\"],\"2045765932\":[\"The formal foundations for GenTL are laid by the theory of logic-based conditional transformation [6], [7], [9].\"],\"2113628515\":[\"[12]).\"],\"2120125130\":[\"The formal foundations for GenTL are laid by the theory of logic-based conditional transformation [6], [7], [9].\"],\"2131755133\":[\"For instance, JTransformer, our own logic meta-programming tool for Java [8], [5] represents methods by a predicate with seven parameters.\",\"GenTL is translated to the logic meta-programming representation supported by the JTransformer system [5], [8].\",\"Efficiency and scalability of this system in conjunction with the compilation of logic programs supported by the CTC [2] is demonstrated in [8].\"]},\"PR\":[2795013376,1555552217,2183928278,2141164043,1967199258,2185166801,2182551403,2888158939,160834882,793427556,2620656284,60611840,2900622615,2283840126,156125946,2295283639,2404364152,2795197718,2552367307,1579097834,2795013376,1555552217,2183928278,2141164043,1967199258,2185166801,2182551403,2888158939,160834882,793427556,2620656284,60611840,2900622615,2283840126,156125946,2295283639,2404364152,2795197718,2552367307,1579097834],\"ANF\":[{\"FN\":\"Daniel\",\"LN\":\"Speicher\",\"S\":1},{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":2},{\"FN\":\"Günter\",\"LN\":\"Kniesel\",\"S\":3}],\"BV\":\"WRT\",\"BT\":\"p\"}"},{"logprob":-21.105,"Id":2027457117,"Ty":"0","Ti":"a context management infrastructure with language integration support","Pt":"0","L":"en","Y":2011,"D":"2011-07-25","CC":9,"ECC":9,"RId":[2138363365,1577783107,2143238865,131217332,2150275961,2622218184,2012173916,2163167025,2090764929,2894705492,564502763,1531374985],"W":["context","infrastructure","integration","language","management","support"],"AA":[{"DAuN":"Tobias Rho","AuN":"tobias rho","AuId":2140223330,"DAfN":"University of Bonn","AfN":"university of bonn","AfId":135140700,"S":1},{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":135591984,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":2},{"DAuN":"Stephan Lerche","AuN":"stephan lerche","AuId":2224010944,"DAfN":"University of Bonn","AfN":"university of bonn","AfId":135140700,"S":3},{"DAuN":"Armin B. Cremers","AuN":"armin b cremers","AuId":2098737035,"DAfN":"University of Bonn","AfN":"university of bonn","AfId":135140700,"S":4},{"DAuN":"Robert Hirschfeld","AuN":"robert hirschfeld","AuId":2154319088,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":5}],"F":[{"DFN":"Semantic Web","FN":"semantic web","FId":2129575},{"DFN":"RDF query language","FN":"rdf query language","FId":96956885},{"DFN":"Query language","FN":"query language","FId":192028432},{"DFN":"Natural language processing","FN":"natural language processing","FId":204321447},{"DFN":"Fourth-generation programming language","FN":"fourth generation programming language","FId":145628200},{"DFN":"Data control language","FN":"data control language","FId":32977378},{"DFN":"Context model","FN":"context model","FId":183322885},{"DFN":"Context management","FN":"context management","FId":2776285913},{"DFN":"Context awareness","FN":"context awareness","FId":2781368080},{"DFN":"Computer science","FN":"computer science","FId":41008148},{"DFN":"Artificial intelligence","FN":"artificial intelligence","FId":154945302}],"E":"{\"DN\":\"A context management infrastructure with language integration support\",\"IA\":{\"IndexLength\":134,\"InvertedIndex\":{\"A\":[0],\"range\":[1],\"of\":[2,15,49,72,91,103,130],\"context-management\":[3,60],\"systems\":[4],\"in\":[5],\"the\":[6,10,119,128],\"past\":[7],\"have\":[8],\"motivated\":[9],\"need\":[11],\"for\":[12,25,88,118],\"development\":[13],\"support\":[14],\"context-aware\":[16],\"applications.\":[17],\"They\":[18],\"typically\":[19],\"provide\":[20],\"APIs\":[21],\"and\":[22,81,97,105,126],\"query\":[23,116],\"languages\":[24],\"context\":[26,30,64,107],\"analysis.\":[27],\"Reacting\":[28],\"to\":[29,40,47,75],\"changes,\":[31],\"however,\":[32],\"is\":[33,86],\"either\":[34],\"not\":[35],\"at\":[36],\"all\":[37],\"or\":[38],\"only\":[39],\"a\":[41,50,59,99,110,115],\"limited\":[42],\"extend\":[43],\"supported\":[44],\"by\":[45,69],\"adhering\":[46],\"constraints\":[48],\"framework.\":[51],\"In\":[54],\"this\":[55],\"paper,\":[56],\"we\":[57,113],\"present\":[58,123],\"system\":[61],\"that\":[62],\"combines\":[63],\"reasoning\":[65],\"with\":[66,93],\"context-dependent\":[67],\"behavior\":[68],\"taking\":[70],\"advantage\":[71],\"language\":[73,95],\"approaches\":[74],\"dynamic\":[76],\"adaptation,\":[77],\"such\":[78],\"as\":[79],\"aspect-\":[80],\"context-oriented\":[82],\"programming.\":[83],\"Our\":[84],\"framework\":[85],\"open\":[87],\"different\":[89],\"levels\":[90],\"integration\":[92],\"programming\":[94],\"extensions\":[96],\"offers\":[98],\"dynamic,\":[100],\"strategy-based\":[101],\"aggregation\":[102],\"local\":[104],\"distributed\":[106],\"sources.\":[108],\"As\":[109],\"first\":[111],\"step,\":[112],\"implemented\":[114],\"library\":[117],\"JCop\":[120],\"language.\":[121],\"We\":[122],\"its\":[124],\"API\":[125],\"show\":[127],\"implementation\":[129],\"an\":[131],\"example\":[132],\"application.\":[133]}},\"S\":[{\"Ty\":3,\"U\":\"http://www.hirschfeld.org/writings/media/RhoAppeltauerLercheCremersHirschfeld_2011_AContextManagementInfrastructurWithLanguageIntegrationSupport_AcmDL.pdf\"},{\"Ty\":1,\"U\":\"https://dl.acm.org/citation.cfm?id=2068739\"},{\"Ty\":1,\"U\":\"https://doi.acm.org/10.1145/2068736.2068739\"},{\"Ty\":0,\"U\":\"http://dl.acm.org/citation.cfm?id=2068739\"}],\"VFN\":\"Proceedings of the 3rd International Workshop on Context-Oriented Programming\",\"FP\":3,\"DOI\":\"10.1145/2068736.2068739\",\"CC\":{\"131217332\":[\"We adopted the prefix namespace binding from XML namespaces [8] in order to separate the simple name from a URI and also to distinguish classes and property names in different namespaces.\"],\"564502763\":[\"Additionally, both requests can be combined with an LDAP (Lightweight Directory Access Protocol)[2] filter string to filter context sources via meta-data attached to the context source service.\"],\"1531374985\":[\"The returned triples are added to the factbase and can be queried by later expressions, following logical update semantics [3].\"],\"1577783107\":[\"The context model is described with the help of the Web Ontology Language OWL [9].\"],\"2012173916\":[\"One example is the SOCAM approach [5] by Gu et al.\"],\"2090764929\":[\"Du and Wang developed a programming approach for contextawareness on mobile devices [4] that supports method interception at each state transition, that is, at each entrance and exit of contexts.\"],\"2143238865\":[\"The latter is also the focus of ongoing language design research mainly in the domain of context-oriented [6] and aspectoriented programming [7].\"],\"2150275961\":[\"The latter is also the focus of ongoing language design research mainly in the domain of context-oriented [6] and aspectoriented programming [7].\",\"JCop is a language extension to Java implementing the context-oriented programming approach [6].\"],\"2163167025\":[\"Semantic Space [12] focuses on three main tasks: to provide an explicit representation of the raw context data, to provide the means to acquire contexts via expressive queries and thirdly to provide high-level contexts through reasoning.\"],\"2622218184\":[\", [10]) extend OSGi to a remote framework.\"],\"2894705492\":[\"The prolog engine is based on SWI-Prolog and its semantic-web library [13].\"]},\"PR\":[2335203551,2484866903,2607154206,176870948,832368302,2312945723,2737854826,1557811574,2237223166,2619280494,2625635013,2186087570,2623768292,2295079279,939271655,1881612611,108344277,2244212087,2489483268,26646340,2335203551,2484866903,2607154206,176870948,832368302,2312945723,2737854826,1557811574,2237223166,2619280494,2625635013,2186087570,2623768292,2295079279,939271655,1881612611,108344277,2244212087,2489483268,26646340],\"ANF\":[{\"FN\":\"Tobias\",\"LN\":\"Rho\",\"S\":1},{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":2},{\"FN\":\"Stephan\",\"LN\":\"Lerche\",\"S\":3},{\"FN\":\"Armin B.\",\"LN\":\"Cremers\",\"S\":4},{\"FN\":\"Robert\",\"LN\":\"Hirschfeld\",\"S\":5}],\"BV\":\"Proceedings of the 3rd International Workshop on Context-Oriented Programming\",\"BT\":\"p\",\"PB\":\"ACM\"}"},{"logprob":-21.137,"Id":2081821914,"Ty":"0","Ti":"towards type safe jcop a type system for layer inheritance and first class layers","Pt":"0","L":"en","Y":2014,"D":"2014-07-28","CC":6,"ECC":6,"RId":[2480195817,2150275961,2033348393,2060640309,1985637830,2111576674,6784408,2182749898,2103457658,2055190380],"W":["class","first","inheritance","jcop","layer","layers","safe","system","towards","type"],"AA":[{"DAuN":"Hiroaki Inoue","AuN":"hiroaki inoue","AuId":2489204954,"DAfN":"Kyoto University","AfN":"kyoto university","AfId":22299242,"S":1},{"DAuN":"Atsushi Igarashi","AuN":"atsushi igarashi","AuId":2097080023,"DAfN":"Kyoto University","AfN":"kyoto university","AfId":22299242,"S":2},{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":135591984,"DAfN":"SAP Innovation Center, Potsdam, Germany","S":3},{"DAuN":"Robert Hirschfeld","AuN":"robert hirschfeld","AuId":2154319088,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":4}],"F":[{"DFN":"Programming language","FN":"programming language","FId":199360897},{"DFN":"Java","FN":"java","FId":548217200},{"DFN":"First class","FN":"first class","FId":2779849256},{"DFN":"Distributed computing","FN":"distributed computing","FId":120314980},{"DFN":"Computer science","FN":"computer science","FId":41008148}],"E":"{\"DN\":\"Towards Type-Safe JCop: A type system for layer inheritance and first-class layers\",\"IA\":{\"IndexLength\":110,\"InvertedIndex\":{\"This\":[0],\"paper\":[1],\"describes\":[2],\"a\":[3,54,66],\"type\":[4,22,67,75,101],\"system\":[5,23,68,76,102],\"for\":[6,17,69],\"JCop,\":[7],\"which\":[8],\"is\":[9,28,77],\"an\":[10],\"extension\":[11],\"of\":[12,38,43,57],\"Java\":[13],\"with\":[14],\"language\":[15,108],\"mechanisms\":[16],\"context-oriented\":[18,58],\"programming.\":[19,59],\"A\":[20],\"simple\":[21],\"as\":[24,88],\"in\":[25],\"Java,\":[26],\"however,\":[27],\"not\":[29,78],\"sufficient\":[30],\"to\":[31,35,81,84,106],\"prevent\":[32],\"errors\":[33],\"due\":[34,83],\"the\":[36],\"absence\":[37],\"invoked\":[39],\"methods\":[40],\"because\":[41],\"interfaces\":[42],\"objects\":[44],\"can\":[45,103],\"change\":[46],\"at\":[47],\"run\":[48],\"time\":[49],\"by\":[50],\"dynamic\":[51,70],\"layer\":[52,71,89,95],\"composition,\":[53,72],\"characteristic\":[55],\"feature\":[56],\"Igarashi,\":[60],\"Hirschfeld,\":[61],\"and\":[62,93],\"Masuhara\":[63],\"have\":[64],\"studied\":[65],\"but\":[73],\"their\":[74,100],\"directly\":[79],\"applicable\":[80],\"JCop\":[82],\"JCop-specific\":[85],\"features\":[86],\"such\":[87],\"inheritance,\":[90],\"first-class\":[91],\"layers,\":[92],\"declarative\":[94],\"composition.\":[96],\"We\":[97],\"discuss\":[98],\"how\":[99],\"be\":[104],\"extended\":[105],\"these\":[107],\"features.\":[109]}},\"S\":[{\"Ty\":3,\"U\":\"http://www.hirschfeld.org/writings/media/InoueIgarashiAppeltauerHirschfeld_2014_TowardsTypeSafeJCopATypeSystemForLayerInheritanceAndFirstClassLayers_AcmDL.pdf\"},{\"Ty\":1,\"U\":\"https://doi.acm.org/10.1145/2637066.2637073\"},{\"Ty\":1,\"U\":\"https://dl.acm.org/citation.cfm?id=2637066.2637073\"}],\"VFN\":\"Proceedings of 6th International Workshop on Context-Oriented Programming\",\"FP\":7,\"DOI\":\"10.1145/2637066.2637073\",\"CC\":{\"1985637830\":[\"In the first type system for ContextFJ [6], a layer cannot introduce a new method and so the interface of an object does not change for its lifetime, making deactivation trivially safe.\"],\"2033348393\":[\"Igarashi, Hirschfeld, and Masuhara [7] have studied this problem and developed a type system for a formal calculus ContextFJ, a COP extension of Featherweight Java [8].\"],\"2055190380\":[\"BaseLayer [] layers = new BaseLayer [10]; layers [0] = new Rain(); layers [1] = new OtherInfo (); with(layers[i]){ .\",\"Recent work by Kamina, Aotani, and Igarashi [10] proposes another way to deal with type-safe deactivation.\"],\"2060640309\":[\"This feature is motivated by layer composition from layer dependencies, and similar to problems treated in [11] and [4].\"],\"2103457658\":[\"Context Petri Nets [3], a context-oriented extension of Petri Nets, support various kinds of declarations of dependency between layers, such as implication, requirement, and exclusion.\"],\"2111576674\":[\"As a running example, we consider programming a graphical computer game called RetroAdventure, inspired by [2].\",\"In addition to the block-style (de)activation mechanisms, JCop provides declarative layer composition [2]—a mechanism to (de)activate layer instances by using AspectJ-like pointcuts [12] and context classes.\",\"We omit how an instance of a context class can be activated, as it is not very important for the present paper; see Appeltauer and Hirschfeld [2] for details.\"],\"2150275961\":[\"Context-Oriented Programming (COP) [5] is an approach to describing context-dependent behavioral variations in a\"],\"2182749898\":[\"Igarashi, Hirschfeld and Masuhara [7] have studied this problem and developed a formal calculus ContextFJ, which models a core of COP, with a provably sound type system.\",\"Igarashi, Hirschfeld, and Masuhara [7] have studied this problem and developed a type system for a formal calculus ContextFJ, a COP extension of Featherweight Java [8].\",\"In the second type system for ContextFJ by Igarashi, Hirschfeld, and Masuhara [7], a layer can introduce a new method but deactivation is dropped for the sake of simplicity.\",\"We refer readers to Igarashi, Hirschfeld, and Masuhara [7] for basic comparisons with other composition mechanisms and type systems for COP.\"],\"2480195817\":[\"In addition to the block-style (de)activation mechanisms, JCop provides declarative layer composition [2]—a mechanism to (de)activate layer instances by using AspectJ-like pointcuts [12] and context classes.\"]},\"PR\":[2150275961,2182749898,2753187437,2148878240,2783879556,1902828588,2375177547,67068934,192592871,2060640309,97741736,1529056891,2391591072,2003007661,254272710,2203630088,2186563730,2811509962,2059767223,2183162906,2150275961,2182749898,2753187437,2148878240,2783879556,1902828588,2375177547,67068934,192592871,2060640309,97741736,1529056891,2391591072,2003007661,254272710,2203630088,2186563730,2811509962,2059767223,2183162906],\"ANF\":[{\"FN\":\"Hiroaki\",\"LN\":\"Inoue\",\"S\":1},{\"FN\":\"Atsushi\",\"LN\":\"Igarashi\",\"S\":2},{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":3},{\"FN\":\"Robert\",\"LN\":\"Hirschfeld\",\"S\":4}],\"BV\":\"Proceedings of 6th International Workshop on Context-Oriented Programming\",\"BT\":\"p\",\"PB\":\"ACM\"}"},{"logprob":-21.236,"Id":1498700995,"Ty":"0","Ti":"towards concrete syntax patterns for logic based transformation rules","Pt":"1","Y":2008,"D":"2008-01-01","CC":8,"ECC":8,"W":["concrete","logic","patterns","rules","syntax","towards","transformation"],"AA":[{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":2796791905,"S":1},{"DAuN":"Gunter Kniesel","AuN":"gunter kniesel","AuId":729669163,"S":2}],"F":[{"DFN":"Syntax","FN":"syntax","FId":60048249},{"DFN":"Programming language","FN":"programming language","FId":199360897},{"DFN":"Program analysis","FN":"program analysis","FId":98183937},{"DFN":"Metaprogramming","FN":"metaprogramming","FId":35390924},{"DFN":"Logic programming","FN":"logic programming","FId":128838566},{"DFN":"Homoiconicity","FN":"homoiconicity","FId":26663822},{"DFN":"Functional logic programming","FN":"functional logic programming","FId":96315309},{"DFN":"Computational chemistry","FN":"computational chemistry","FId":147597530},{"DFN":"Chemistry","FN":"chemistry","FId":185592680},{"DFN":"Abstract syntax tree","FN":"abstract syntax tree","FId":58646249},{"DFN":"Abstract syntax","FN":"abstract syntax","FId":114408938}],"J":{"JN":"chem phys lett","JId":44567922},"E":"{\"DN\":\"Towards Concrete Syntax Patterns for Logic-based Transformation Rules\",\"S\":[{\"Ty\":0,\"U\":\"http://www.sciencedirect.com/science/article/pii/S1571066108004325\"}],\"VFN\":\"Chemical Physics Letters\",\"PR\":[1625533892,2134429122,2043778658,2242043192,2326631094,928469372,2027696432,1533914434,1568368551,1518253797,1003767669,2404345732,1562454726,10134083,2238546767,1994332976,2168924141,2477605629,178144944,2121949189,1625533892,2134429122,2043778658,2242043192,2326631094,928469372,2027696432,1533914434,1568368551,1518253797,1003767669,2404345732,1562454726,10134083,2238546767,1994332976,2168924141,2477605629,178144944,2121949189],\"ANF\":[{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":1},{\"FN\":\"Gunter\",\"LN\":\"Kniesel\",\"S\":2}],\"BV\":\"Chemical Physics Letters\",\"BT\":\"a\",\"PB\":\"Elsevier\"}"},{"logprob":-21.497,"Id":1645787665,"Ty":"0","Ti":"proceedings of the international workshop on context oriented programming","Pt":"3","L":"en","Y":2012,"D":"2012-06-11","CC":0,"ECC":0,"W":["context","international","oriented","proceedings","programming","workshop"],"AA":[{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":135591984,"DAfN":"Hasso-Plattner-Institut, Germany\t","S":1},{"DAuN":"Sebastián González","AuN":"sebastian gonzalez","AuId":2139110070,"DAfN":"Université catholique de Louvain","AfN":"universite catholique de louvain","AfId":95674353,"S":2},{"DAuN":"Robert Hirschfeld","AuN":"robert hirschfeld","AuId":2154319088,"DAfN":"Hasso-Plattner-Institut, Germany\t","S":3},{"DAuN":"Hidehiko Masuhara","AuN":"hidehiko masuhara","AuId":2087436944,"DAfN":"University of Tokyo","AfN":"university of tokyo","AfId":74801974,"S":4},{"DAuN":"Jorge Vallejos","AuN":"jorge vallejos","AuId":2141614139,"DAfN":"Vrije Universiteit Brussel","AfN":"vrije universiteit brussel","AfId":13469542,"S":5}],"F":[{"DFN":"Thread (computing)","FN":"thread","FId":138101251},{"DFN":"Theoretical computer science","FN":"theoretical computer science","FId":80444323},{"DFN":"Systems engineering","FN":"systems engineering","FId":201995342},{"DFN":"Software system","FN":"software system","FId":149091818},{"DFN":"Simulation","FN":"simulation","FId":44154836},{"DFN":"Ranging","FN":"ranging","FId":115051666},{"DFN":"Implementation","FN":"implementation","FId":26713055},{"DFN":"Computer science","FN":"computer science","FId":41008148}],"C":{"CN":"ecoop","CId":1177184315},"CI":{"CIN":"ecoop 2012","CIId":86332564},"E":"{\"DN\":\"Proceedings of the International Workshop on Context-Oriented Programming\",\"IA\":{\"IndexLength\":218,\"InvertedIndex\":{\"Context\":[0],\"information\":[1],\"plays\":[2],\"an\":[3],\"increasingly\":[4],\"important\":[5],\"role\":[6],\"in\":[7,143,214],\"our\":[8],\"information-centric\":[9],\"world.\":[10],\"Software\":[11],\"systems\":[12],\"must\":[13,21],\"adapt\":[14],\"to\":[15,47,51,69,84,106,115,138,156,166],\"changing\":[16],\"contexts\":[17],\"over\":[18],\"time,\":[19],\"and\":[20,32,120,130,133,178,212],\"change\":[22,42],\"even\":[23],\"while\":[24],\"they\":[25],\"are\":[26,125],\"running.\":[27],\"Unfortunately,\":[28],\"mainstream\":[29],\"programming\":[30],\"languages\":[31],\"development\":[33],\"environments\":[34],\"do\":[35],\"not\":[36],\"support\":[37,71],\"this\":[38,59,215],\"kind\":[39],\"of\":[40,55,78,91,96,171,196,201],\"dynamic\":[41,79],\"very\":[43],\"well,\":[44],\"leading\":[45],\"developers\":[46],\"implement\":[48],\"complex\":[49],\"designs\":[50],\"anticipate\":[52],\"various\":[53],\"dimensions\":[54],\"variability.\":[56],\"Starting\":[57],\"from\":[58,136],\"observation,\":[60],\"Context-Oriented\":[61,102,128],\"Programming\":[62,103,129],\"(COP)\":[63],\"has\":[64],\"emerged\":[65],\"as\":[66,111],\"a\":[67,75,112,163],\"solution\":[68],\"directly\":[70],\"variability\":[72],\"depending\":[73],\"on\":[74,88,101,127],\"wide\":[76],\"range\":[77],\"attributes,\":[80],\"making\":[81],\"it\":[82],\"possible\":[83],\"dispatch\":[85,150],\"run-time\":[86,159],\"behaviour\":[87],\"any\":[89],\"property\":[90],\"the\":[92,97,172,197,202,210],\"execution\":[93],\"context.\\r\\n\\r\\nThe\":[94],\"goal\":[95],\"4th\":[98],\"International\":[99],\"Workshop\":[100],\"(COP'12)\":[104],\"was\":[105,191],\"further\":[107],\"establish\":[108],\"context\":[109],\"orientation\":[110],\"common\":[113],\"thread\":[114],\"language\":[116],\"design,\":[117],\"application\":[118],\"development,\":[119],\"system\":[121],\"support.\":[122],\"Several\":[123],\"researchers\":[124],\"working\":[126],\"related\":[131],\"ideas,\":[132],\"implementations\":[134],\"ranging\":[135],\"prototypes\":[137],\"mature\":[139],\"platform\":[140],\"extensions\":[141],\"used\":[142],\"commercial\":[144],\"deployments\":[145],\"have\":[146],\"illustrated\":[147],\"how\":[148],\"multi-dimensional\":[149],\"can\":[151],\"indeed\":[152],\"be\":[153],\"supported\":[154],\"effectively\":[155],\"achieve\":[157],\"expressive\":[158],\"behavioural\":[160],\"variations.\\r\\n\\r\\nThis\":[161],\"is\":[162],\"follow-up\":[164],\"event\":[165],\"3\":[167,194],\"consecutive\":[168],\"successful\":[169],\"editions\":[170],\"workshop\":[173,185,216],\"at\":[174,209],\"ECOOP\":[175],\"2009,\":[176],\"2010\":[177],\"2011,\":[179],\"each\":[180],\"attracting\":[181],\"around\":[182],\"30\":[183],\"participants.\\r\\n\\r\\nThe\":[184],\"received\":[186],\"5\":[187,203],\"submissions.\":[188],\"Each\":[189],\"paper\":[190],\"reviewed\":[192],\"by\":[193],\"members\":[195],\"program\":[198],\"committee.\":[199],\"All\":[200],\"submissions\":[204],\"were\":[205],\"selected\":[206],\"for\":[207],\"presentation\":[208],\"workshop,\":[211],\"publication\":[213],\"proceedings.\":[217]}},\"S\":[{\"Ty\":1,\"U\":\"https://dial.uclouvain.be/pr/boreal/object/boreal:122329\"},{\"Ty\":1,\"U\":\"http://dial.academielouvain.be/handle/boreal:122329?site_name=BOREAL\"}],\"VFN\":\"European Conference on Object-Oriented Programming\",\"VSN\":\"ECOOP\",\"PR\":[2250541251,2090461980,2614574419,2249672756,1583676598,2121727976,1486670242,2744018850,2724770279,2617486455,1669821313,947889820,2251267611,1527896317,2290118463,1493285459,2184117991,2052592694,2890397558,2248181659,2250541251,2090461980,2614574419,2249672756,1583676598,2121727976,1486670242,2744018850,2724770279,2617486455,1669821313,947889820,2251267611,1527896317,2290118463,1493285459,2184117991,2052592694,2890397558,2248181659],\"ANF\":[{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":1},{\"FN\":\"Sebastián\",\"LN\":\"González\",\"S\":2},{\"FN\":\"Robert\",\"LN\":\"Hirschfeld\",\"S\":3},{\"FN\":\"Hidehiko\",\"LN\":\"Masuhara\",\"S\":4},{\"FN\":\"Jorge\",\"LN\":\"Vallejos\",\"S\":5}],\"BV\":\"ECOOP'12 26th European Conference on Object-Oriented Programming\",\"BT\":\"p\"}"},{"logprob":-21.818,"Id":2105053310,"Ty":"0","Ti":"declarative layer composition in framework based environments","Pt":"0","L":"en","Y":2012,"D":"2012-06-11","CC":2,"ECC":2,"RId":[2138363365,2480195817,2143238865,41699526,2150275961,1992443356,2065646798,2089889705,1978875190,2087175184,2002568360,2090124836,2006015625,2027457117],"W":["composition","declarative","environments","framework","layer"],"AA":[{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":135591984,"DAfN":"Hasso-Plattner-Institut, Germany","S":1},{"DAuN":"Robert Hirschfeld","AuN":"robert hirschfeld","AuId":2154319088,"DAfN":"Hasso-Plattner-Institut, Germany","S":2}],"F":[{"DFN":"Source code","FN":"source code","FId":43126263},{"DFN":"Separation of concerns","FN":"separation of concerns","FId":76214141},{"DFN":"Programming language","FN":"programming language","FId":199360897},{"DFN":"Modular programming","FN":"modular programming","FId":88482812},{"DFN":"Language construct","FN":"language construct","FId":48859967},{"DFN":"Java","FN":"java","FId":548217200},{"DFN":"Implementation","FN":"implementation","FId":26713055},{"DFN":"Computer science","FN":"computer science","FId":41008148},{"DFN":"Application domain","FN":"application domain","FId":36183442},{"DFN":"Abstraction","FN":"abstraction","FId":124304363}],"E":"{\"DN\":\"Declarative layer composition in framework-based environments\",\"IA\":{\"IndexLength\":142,\"InvertedIndex\":{\"Context-oriented\":[0],\"programming\":[1,57],\"(COP)\":[2],\"can\":[3],\"improve\":[4],\"modularity\":[5],\"by\":[6,50,135],\"dedicated\":[7],\"language\":[8,52,127,136],\"constructs\":[9,137],\"for\":[10,138],\"crosscutting\":[11,72,87,133],\"concerns.\":[12,79],\"Although\":[13],\"COP\":[14,51,117],\"could\":[15],\"be\":[16],\"used\":[17,56],\"in\":[18,22,41,90,93],\"any\":[19],\"application\":[20],\"domain\":[21],\"general,\":[23],\"its\":[24],\"current\":[25],\"implementations\":[26],\"may\":[27],\"require\":[28],\"adaptations\":[29],\"of\":[30,46,78,99,131],\"source\":[31],\"code\":[32],\"that\":[33,74,111],\"is\":[34],\"not\":[35],\"accessible\":[36],\"to\":[37],\"the\":[38,44,76,129],\"developer.\":[39],\"This,\":[40],\"turn,\":[42],\"limits\":[43],\"interaction\":[45],\"adaptation\":[47],\"mechanisms\":[48],\"provided\":[49],\"extensions\":[53],\"with\":[54],\"widely\":[55],\"abstractions\":[58],\"such\":[59,100],\"as\":[60,70],\"frameworks.\":[61],\"As\":[62,95],\"a\":[63,71,96,101,106,115],\"result,\":[64],\"dynamic\":[65],\"control\":[66],\"over\":[67],\"layers\":[68],\"emerges\":[69],\"concern\":[73],\"obstructs\":[75],\"separation\":[77],\"In\":[82],\"this\":[83],\"paper,\":[84],\"we\":[85,104,112,120],\"discuss\":[86],\"layer\":[88,140],\"composition\":[89],\"framework-based\":[91,102],\"applications\":[92],\"detail.\":[94],\"concrete\":[97],\"example\":[98],\"application,\":[103],\"present\":[105],\"simple\":[107],\"action\":[108],\"adventure\":[109],\"game\":[110],\"implemented\":[113],\"using\":[114],\"conventional\":[116],\"language.\":[118],\"Finally,\":[119],\"show,\":[121],\"how\":[122],\"our\":[123],\"JCop\":[125],\"supports\":[128],\"modularization\":[130],\"these\":[132],\"concerns\":[134],\"declarative\":[139],\"composition.\":[141]}},\"S\":[{\"Ty\":3,\"U\":\"http://www.hirschfeld.org/writings/media/AppeltauerHirschfeld_2012_DeclarativeLayerCompositionInFrameworkBasedEnvironments_AcmDL.pdf\"},{\"Ty\":3,\"U\":\"http://www.lirmm.fr/~ducour/Doc-objets/ECOOP2012/COP/a1-appeltauer.pdf\"},{\"Ty\":1,\"U\":\"https://dl.acm.org/citation.cfm?doid=2307436.2307437\"}],\"VFN\":\"Proceedings of the International Workshop on Context-Oriented Programming\",\"FP\":1,\"LP\":6,\"DOI\":\"10.1145/2307436.2307437\",\"CC\":{\"41699526\":[\"However, research so far did not explicitly address the incorporation of COP with application domains that employ frameworks [8].\",\"A problem may occur, if a layer composition must be executed within the framework code, because one property that distinguishes frameworks from other libraries is that they prohibit access to their implementation [8].\"],\"1978875190\":[\"The JavaScript extension ContextJS [12] addresses the need for additional scoping strategies, such as instance-specific and structural scoping, and proposes an open implementation for COP layer composition.\"],\"1992443356\":[\"The context-oriented programming (COP) [6, 4] approach supports the modularization of crosscutting concerns [11] and their control at runtime.\"],\"2002568360\":[\"The Python extension ContextPy [7] provides the concept of guards to declare layer relationships.\"],\"2006015625\":[\"AstroPic [17] is an image gallery application for mobile devices.\"],\"2027457117\":[\"WhenToDo [16] is a ToDo application that helps to prioritize tasks depending on the current working environment and situation.\",\"WhenToDo uses a context query framework [16] that allows for reasoning about Web-based context information, and incorporates the reaction to context change with layer activation.\"],\"2065646798\":[\"a specific type of crosscutting concerns, the so called heterogeneous crosscutting concerns [1].\",\"ting concerns require different source code to be executed at their join points (points in the program’s structure or control flow [11]), whereas homogeneous crosscutting concerns require the same source code to be executed at their join points [1].\"],\"2087175184\":[\"Similarly, another Python extension, PyContext [18], supports a kind of implicit layer activation that is designed to deal with the issue of scattered layer activations.\"],\"2090124836\":[\"The EventCJ [9] language has been published shortly after JCop [3] and both languages are closely related.\"],\"2143238865\":[\"The context-oriented programming (COP) [6, 4] approach supports the modularization of crosscutting concerns [11] and their control at runtime.\",\"ting concerns require different source code to be executed at their join points (points in the program’s structure or control flow [11]), whereas homogeneous crosscutting concerns require the same source code to be executed at their join points [1].\",\"For a better modularization, we propose to use the features of JCop that integrates COP with an aspectoriented programming [11] language dedicated to the specification of declarative layer composition.\"],\"2150275961\":[\"The context-oriented programming (COP) [6, 4] approach supports the modularization of crosscutting concerns [11] and their control at runtime.\",\"These two statements are typically denoted as with and without statements [6].\"],\"2480195817\":[\"JCop’s declarative layer compositions are encapsulated by a context class declaration, a special type declaration that can contain pointcuts and advice constructs, known form aspect languages such as AspectJ [10], and plain class members.\",\"However, JCop restricts its join point model to method executions and dynamic conditions, whereas EventCJ inherits the whole AspectJ join point model [10].\"]},\"PR\":[2162152221,2120306315,2418516776,131416673,144707335,2038176785,2385340562,1603120467,1972916949,2154006517,1971981534,1748012875,2514305392,1502821974,2755783464,2069173317,2011994953,2049582601,2067238940,2041804590,2162152221,2120306315,2418516776,131416673,144707335,2038176785,2385340562,1603120467,1972916949,2154006517,1971981534,1748012875,2514305392,1502821974,2755783464,2069173317,2011994953,2049582601,2067238940,2041804590],\"ANF\":[{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":1},{\"FN\":\"Robert\",\"LN\":\"Hirschfeld\",\"S\":2}],\"BV\":\"Proceedings of the International Workshop on Context-Oriented Programming\",\"BT\":\"p\",\"PB\":\"ACM\"}"},{"logprob":-21.998,"Id":2038371475,"Ty":"0","Ti":"contextlua dynamic behavioral variations in computer games","Pt":"0","L":"en","Y":2010,"D":"2010-06-22","CC":4,"ECC":4,"RId":[1649645444,1489092837,2150275961,2737560561,1992443356,2091731831,2144114063,2087175184,2164128966,141950294,2002568360,79030657],"W":["behavioral","computer","contextlua","dynamic","games","variations"],"AA":[{"DAuN":"Benjamin Hosain Wasty","AuN":"benjamin hosain wasty","AuId":2223928005,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":1},{"DAuN":"Amir Semmo","AuN":"amir semmo","AuId":1525858591,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":2},{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":135591984,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":3},{"DAuN":"Bastian Steinert","AuN":"bastian steinert","AuId":2142371068,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":4},{"DAuN":"Robert Hirschfeld","AuN":"robert hirschfeld","AuId":2154319088,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":5}],"F":[{"DFN":"Very high-level programming language","FN":"very high level programming language","FId":169796678},{"DFN":"Simulation","FN":"simulation","FId":44154836},{"DFN":"Programming language theory","FN":"programming language theory","FId":18701968},{"DFN":"Programming domain","FN":"programming domain","FId":119263510},{"DFN":"Game programming","FN":"game programming","FId":109347269},{"DFN":"Game mechanics","FN":"game mechanics","FId":170828538},{"DFN":"First-generation programming language","FN":"first generation programming language","FId":570499},{"DFN":"Extensible programming","FN":"extensible programming","FId":131531359},{"DFN":"Computer science","FN":"computer science","FId":41008148},{"DFN":"Computer network programming","FN":"computer network programming","FId":113041634}],"E":"{\"DN\":\"ContextLua: dynamic behavioral variations in computer games\",\"IA\":{\"IndexLength\":93,\"InvertedIndex\":{\"Behavioral\":[0],\"variations\":[1,21,40,88],\"are\":[2,10],\"central\":[3],\"to\":[4,24,37,57,81],\"modern\":[5],\"computer\":[6,33,71],\"games\":[7,34],\"as\":[8],\"they\":[9],\"making\":[11],\"the\":[12,25,30,58,68,90],\"gameplay\":[13],\"a\":[14],\"more\":[15],\"interesting\":[16],\"user\":[17],\"experience.\":[18],\"However,\":[19],\"these\":[20],\"significantly\":[22],\"add\":[23],\"implementation\":[26],\"complexity.\":[27],\"We\":[28],\"discuss\":[29],\"domain\":[31],\"of\":[32,47,70,89],\"with\":[35],\"respect\":[36],\"dynamic\":[38,59],\"behavioral\":[39],\"and\":[41,86],\"argue\":[42],\"that\":[43],\"context-oriented\":[44],\"programming\":[45,76],\"is\":[46,64],\"special\":[48],\"interest\":[49],\"for\":[50,84],\"this\":[51],\"domain.\":[52],\"This\":[53],\"motivates\":[54],\"our\":[55],\"extension\":[56],\"scripting\":[60],\"language\":[61],\"Lua,\":[62],\"which\":[63],\"frequently\":[65],\"used\":[66],\"in\":[67],\"development\":[69],\"games.\":[72],\"Our\":[73],\"newly\":[74],\"provided\":[75],\"constructs\":[77],\"allow\":[78],\"game\":[79],\"developers\":[80],\"use\":[82],\"layers\":[83],\"defining\":[85],\"activating\":[87],\"basic\":[91],\"gameplay.\":[92]}},\"S\":[{\"Ty\":1,\"U\":\"https://dl.acm.org/citation.cfm?id=1930021.1930026\"}],\"VFN\":\"Proceedings of the 2nd International Workshop on Context-Oriented Programming\",\"FP\":5,\"DOI\":\"10.1145/1930021.1930026\",\"CC\":{\"79030657\":[\"Lua was created in 1993 by Roberto Ierusalimschy, Waldemar Celes and Luiz Henrique de Figueiredo [ 11 ].\"],\"1649645444\":[\"More sophisticated approaches use object-oriented programming concepts in order to benefit from dynamic binding and reducing complexity on implementation level (state pattern [ 8 ]).\"],\"1992443356\":[\"The Lisp extension ContextL [ 4 ] is based on the Common Lisp Object System; ContextPy [10] and PyContext [14] use Python’s reflective API.\"],\"2002568360\":[\"The Lisp extension ContextL [4] is based on the Common Lisp Object System; ContextPy [ 10 ] and PyContext [14] use Python’s reflective API.\"],\"2087175184\":[\"The Lisp extension ContextL [4] is based on the Common Lisp Object System; ContextPy [10] and PyContext [ 14 ] use Python’s reflective API.\"],\"2091731831\":[\"Their main motivation was to create a language that on the one hand permits lightweight and embeddable scripting, whose syntax is easy to understand for non-programmers, and on the other hand permits high portability on diversive platforms [ 12 ].\"],\"2144114063\":[\"In previous work [ 3 ], we describe two main implementation strategies for layer-based recomposition that take place either at composition time, where method references are relinked at any occurrence of with and without ,o r atexecution time, where method versions are selected just before their execution.\"],\"2150275961\":[\"Context-oriented programming (COP) is a promising programming paradigm to permit and improve the maintainability, robustness and reusability of systems that must fit in these highly dynamic environments [ 9 ].\"],\"2164128966\":[\"Instead, variations in gameplay and behavior are taken into consideration in order to remove easily predictable behavior by adapting the gameplay to specific changes in the environment and actions of the player, which is commonly related to artificial intelligence [7,  13 ].\"]},\"PR\":[2238450825,103287021,2810365728,2071550130,591917463,1969733257,1513632345,1979966850,189717293,2889548350,2892329126,2186794658,1018867163,2185150188,1516150409,2056426990,2260407304,2482340821,2900224964,236237575,2238450825,103287021,2810365728,2071550130,591917463,1969733257,1513632345,1979966850,189717293,2889548350,2892329126,2186794658,1018867163,2185150188,1516150409,2056426990,2260407304,2482340821,2900224964,236237575],\"ANF\":[{\"FN\":\"Benjamin Hosain\",\"LN\":\"Wasty\",\"S\":1},{\"FN\":\"Amir\",\"LN\":\"Semmo\",\"S\":2},{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":3},{\"FN\":\"Bastian\",\"LN\":\"Steinert\",\"S\":4},{\"FN\":\"Robert\",\"LN\":\"Hirschfeld\",\"S\":5}],\"BV\":\"Proceedings of the 2nd International Workshop on Context-Oriented Programming\",\"BT\":\"p\",\"PB\":\"ACM\"}"},{"logprob":-22.134,"Id":140370410,"Ty":"0","Ti":"explicit language and infrastructure support for context aware services","Pt":"0","Y":2008,"D":"2008-01-01","CC":5,"ECC":5,"RId":[2150275961,1565818272,2150491652,170057163,1513110806,2160377668,169400382],"W":["aware","context","explicit","infrastructure","language","services","support"],"AA":[{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":135591984,"DAfN":"Universitat Potsdam","S":1},{"DAuN":"Robert Hirschfeld","AuN":"robert hirschfeld","AuId":2154319088,"DAfN":"Universitat Potsdam","S":2}],"F":[{"DFN":"World Wide Web","FN":"world wide web","FId":136764020},{"DFN":"Programming paradigm","FN":"programming paradigm","FId":34165917},{"DFN":"Programming language specification","FN":"programming language specification","FId":15077461},{"DFN":"Programming language","FN":"programming language","FId":199360897},{"DFN":"Programming domain","FN":"programming domain","FId":119263510},{"DFN":"Inductive programming","FN":"inductive programming","FId":50033165},{"DFN":"Fourth-generation programming language","FN":"fourth generation programming language","FId":145628200},{"DFN":"First-generation programming language","FN":"first generation programming language","FId":570499},{"DFN":"Fifth-generation programming language","FN":"fifth generation programming language","FId":199305712},{"DFN":"Extensible programming","FN":"extensible programming","FId":131531359},{"DFN":"Computer science","FN":"computer science","FId":41008148}],"E":"{\"DN\":\"Explicit Language and Infrastructure Support for Context-aware Services.\",\"IA\":{\"IndexLength\":51,\"InvertedIndex\":{\"Dealing\":[0],\"with\":[1,24],\"context\":[2],\"information\":[3],\"is\":[4],\"an\":[5,40],\"important\":[6],\"concern\":[7],\"for\":[8,35],\"mobile\":[9,36],\"service\":[10],\"computing.\":[11],\"However,\":[12],\"modern\":[13],\"frameworks\":[14],\"and\":[15,38],\"programming\":[16,49],\"languages\":[17],\"do\":[18],\"not\":[19],\"directly\":[20],\"support\":[21],\"context-dependent\":[22],\"behavior\":[23],\"first\":[25],\"class\":[26],\"entities.\":[27],\"In\":[28],\"this\":[29],\"paper,\":[30],\"we\":[31],\"present\":[32],\"Context-oriented\":[33],\"Programming\":[34],\"applications\":[37],\"provide\":[39],\"overview\":[41],\"of\":[42],\"our\":[43],\"context-oriented\":[44],\"extension\":[45],\"to\":[46],\"the\":[47],\"Java\":[48],\"language.\":[50]}},\"S\":[{\"Ty\":3,\"U\":\"http://www.hirschfeld.org/writings/media/AppeltauerHirschfeld_2008_LanguageAndInfrastructureSupportForContextAwareServices.pdf\"},{\"Ty\":3,\"U\":\"http://www.hpi.uni-potsdam.de/hirschfeld/publications/media/AppeltauerHirschfeld_2008_LanguageAndInfrastructureSupportForContextAwareServices.pdf\"},{\"Ty\":1,\"U\":\"http://dblp.uni-trier.de/db/conf/gi/gi2008-1.html#AppeltauerH07\"}],\"VFN\":\"GI Jahrestagung (1)\",\"FP\":164,\"LP\":170,\"CC\":{\"170057163\":[\"Contextoriented Programming (COP) [ HCN08 ] enriches programming languages and execution environments with features to explicitly represent context-dependent behavioral variations.\\u001bContext-oriented programming [ HCN08 ] is a paradigm supporting the development of behavioral variations that depend on execution context.\\u001bA broad introduction to COP is provided by [ HCN08 ].\\u001bA first prototype of ContextJ, ContextJ* [ HCN08 ], has been developed previously.\"],\"2160377668\":[\"For a feature comparison of distributed AOP approaches, see [ DBC07 ].\"]},\"PR\":[1992443356,2089889705,1584434869,2735331557,2187244084,1504725456,211137439,1992660330,54454771,2774366,2119777643,2740197935,2488426333,2574619861,2466237336,56677460,2312776306,2390323998,2184706495,1589783925,1992443356,2089889705,1584434869,2735331557,2187244084,1504725456,211137439,1992660330,54454771,2774366,2119777643,2740197935,2488426333,2574619861,2466237336,56677460,2312776306,2390323998,2184706495,1589783925],\"ANF\":[{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":1},{\"FN\":\"Robert\",\"LN\":\"Hirschfeld\",\"S\":2}],\"BV\":\"GI Jahrestagung (1)\",\"BT\":\"a\"}"},{"logprob":-22.523,"Id":55389199,"Ty":"0","Ti":"layered method dispatch with invokedynamic","Pt":"0","Y":2010,"D":"2010-01-01","CC":1,"ECC":1,"RId":[2150275961,2144114063,2118300983,2089889705,2086014732,1491095550,1556513858,2172169742,2014881790],"W":["dispatch","invokedynamic","layered"],"AA":[{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":135591984,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":1},{"DAuN":"Michael Haupt","AuN":"michael haupt","AuId":2146662369,"S":2},{"DAuN":"Robert Hirschfeld","AuN":"robert hirschfeld","AuId":2154319088,"S":3}],"F":[{"DFN":"Virtual machine","FN":"virtual machine","FId":25344961},{"DFN":"Spite","FN":"spite","FId":181836184},{"DFN":"Parallel computing","FN":"parallel computing","FId":173608175},{"DFN":"Java","FN":"java","FId":548217200},{"DFN":"Computer science","FN":"computer science","FId":41008148},{"DFN":"Compiler","FN":"compiler","FId":169590947},{"DFN":"Bytecode","FN":"bytecode","FId":2779818221}],"E":"{\"DN\":\"Layered Method Dispatch With INVOKEDYNAMIC\",\"IA\":{\"IndexLength\":79,\"InvertedIndex\":{\"This\":[0],\"paper\":[1],\"describes\":[2],\"an\":[3],\"implementation\":[4,38,64,76],\"study\":[5],\"in\":[6,65],\"which\":[7],\"we\":[8],\"use\":[9],\"the\":[10,18,25,36,43,57,66,73],\"upcoming\":[11],\"INVOKEDYNAMIC\":[12],\"bytecode\":[13],\"instruction—to\":[14],\"be\":[15],\"supported\":[16],\"by\":[17],\"standard\":[19],\"Java\":[20,28,67],\"virtual\":[21,68],\"machine\":[22],\"starting\":[23],\"with\":[24,40],\"release\":[26],\"of\":[27,42,51,56,59,72],\"7—to\":[29],\"implement\":[30],\"layered\":[31],\"method\":[32],\"dispatch.\":[33],\"We\":[34],\"compare\":[35],\"resulting\":[37],\"approach\":[39],\"that\":[41],\"existing\":[44],\"JCop\":[45,75],\"compiler,\":[46],\"and\":[47],\"present\":[48],\"preliminary\":[49],\"results\":[50],\"comparative\":[52],\"benchmarks.\":[53],\"In\":[54],\"spite\":[55],\"as\":[58],\"now\":[60],\"not\":[61],\"optimized\":[62],\"INVOKEDYAMIC\":[63],\"machine,\":[69],\"performance\":[70],\"characteristics\":[71],\"INVOKEDYNAMIC-based\":[74],\"are\":[77],\"promising.\":[78]}},\"S\":[{\"Ty\":3,\"U\":\"http://www.hirschfeld.org/writings/media/AppeltauerHauptHirschfeld_2010_LayeredMethodDispatchWithINVOKEDYNAMIC_AcmDL.pdf\"},{\"Ty\":3,\"U\":\"https://www.researchgate.net/profile/Michael_Haupt2/publication/234782313_Layered_method_dispatch_with_INVOKEDYNAMIC_an_implementation_study/links/0f31752fb2fe9a76b8000000.pdf\"}],\"VFN\":\"\",\"CC\":{\"1556513858\":[\"COP extensions related to our ID approach make use of their host languages’ support for dynamic delegation, such as ContextS [7] and cj/delMDSOC [11], much like ID does for Java.\"],\"2014881790\":[\"COP extensions related to our ID approach make use of their host languages’ support for dynamic delegation, such as ContextS [7] and cj/delMDSOC [11], much like ID does for Java.\"],\"2086014732\":[\"The upcoming Java 7 release includes a powerful extension to the language’s meta programming facilities: the INVOKEDYNAMIC (henceforth abbreviated “ID”) instruction [10].\"],\"2089889705\":[\"In the following, we only refer to core COP features that have been developed in our previous work on ContextJ [3].\"],\"2118300983\":[\"JCop [1], our current context-oriented Java language extension is implemented as a JastAdd [5] compiler extension, offering a convenient syntax extension and generating plain Java bytecode.\"],\"2144114063\":[\"In previous work [2], we conducted several microbenchmarks to measure possible performance decreases of our implementation of layer-aware method lookup.\",\"Our main motivation to develop an ID-based version of COP are performance issues in previous implementations, as discussed along micro-benchmarks in previous work [2].\",\"For more details on this benchmark, see [2].\",\"Several other COP languages also implement a layer-based recomposition that taking place at composition time, where method references are re-linked at any occurrence of with and without [2].\"],\"2150275961\":[\"We show both implementations along the classic COP example of a class Person that provides a layered method toString for which a partial method is defined in the layer Address [8].\"],\"2172169742\":[\"In previous work, we did the latter for the Java programming language and developed two extensions with dedicated COP language constructs [4, 1].\"]},\"PR\":[1990628165,2837098351,252190987,2278018869,2020191041,2334289172,2391215804,2130334586,2166864541,2231158638,2152619630,2099526513,2083874451,137338904,183374640,1947486167,2112385012,143674253,1502238044,2154762320,1990628165,2837098351,252190987,2278018869,2020191041,2334289172,2391215804,2130334586,2166864541,2231158638,2152619630,2099526513,2083874451,137338904,183374640,1947486167,2112385012,143674253,1502238044,2154762320],\"ANF\":[{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":1},{\"FN\":\"Michael\",\"LN\":\"Haupt\",\"S\":2},{\"FN\":\"Robert\",\"LN\":\"Hirschfeld\",\"S\":3}],\"BT\":\"a\"}"},{"logprob":-23.969,"Id":162129185,"Ty":"0","Ti":"populaid in memory test data generation","Pt":"0","L":"en","Y":2014,"D":"2014-08-05","CC":0,"ECC":0,"RId":[2141499038,1544148736,2038552970,1506075075,2294546257,2082323325,206771271],"W":["data","generation","memory","populaid","test"],"AA":[{"DAuN":"Ralf Teusner","AuN":"ralf teusner","AuId":1971313364,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":1},{"DAuN":"Michael Perscheid","AuN":"michael perscheid","AuId":698431335,"DAfN":"SAP Innovation Center","S":2},{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":135591984,"DAfN":"SAP Innovation Center","S":3},{"DAuN":"Jonas Enderlein","AuN":"jonas enderlein","AuId":2165840458,"DAfN":"University of Potsdam","AfN":"university of potsdam","AfId":176453806,"S":4},{"DAuN":"Thomas Klingbeil","AuN":"thomas klingbeil","AuId":212836417,"DAfN":"SAP Innovation Center","S":5},{"DAuN":"Michael Kusber","AuN":"michael kusber","AuId":653492364,"DAfN":"SAP Innovation Center","S":6}],"F":[{"DFN":"restrict","FN":"restrict","FId":2779521362},{"DFN":"Test data generation","FN":"test data generation","FId":47980962},{"DFN":"Test data","FN":"test data","FId":16910744},{"DFN":"Software development","FN":"software development","FId":529173508},{"DFN":"Scalability","FN":"scalability","FId":48044578},{"DFN":"Legal policies","FN":"legal policies","FId":2909724172},{"DFN":"Information sensitivity","FN":"information sensitivity","FId":137822555},{"DFN":"In-memory database","FN":"in memory database","FId":2779613562},{"DFN":"Database","FN":"database","FId":77088390},{"DFN":"Computer science","FN":"computer science","FId":41008148}],"E":"{\"DN\":\"PopulAid: In-Memory Test Data Generation\",\"IA\":{\"IndexLength\":76,\"InvertedIndex\":{\"During\":[0],\"software\":[1],\"development,\":[2],\"it\":[3],\"is\":[4],\"often\":[5,25],\"necessary\":[6],\"to\":[7,14,28,37,55],\"access\":[8,27],\"real\":[9,33],\"customer\":[10],\"data\":[11,44,71],\"in\":[12],\"order\":[13],\"validate\":[15],\"requirements\":[16],\"and\":[17,22,58],\"performance\":[18],\"thoroughly.\":[19],\"However,\":[20],\"company\":[21],\"legal\":[23],\"policies\":[24],\"restrict\":[26],\"such\":[29],\"sensitive\":[30],\"information.\":[31],\"Without\":[32],\"data,\":[34],\"developers\":[35],\"have\":[36],\"either\":[38],\"create\":[39],\"their\":[40],\"own\":[41],\"customized\":[42],\"test\":[43],\"manually\":[45],\"or\":[46],\"rely\":[47],\"on\":[48],\"standardized\":[49],\"benchmarks.\":[50],\"While\":[51],\"the\":[52,61,69],\"first\":[53],\"tends\":[54],\"lack\":[56],\"scalability\":[57],\"edge\":[59],\"cases,\":[60],\"latter\":[62],\"solves\":[63],\"these\":[64],\"issues\":[65],\"but\":[66],\"cannot\":[67],\"reflect\":[68],\"productive\":[70],\"distributions\":[72],\"of\":[73],\"a\":[74],\"company.\":[75]}},\"S\":[{\"Ty\":3,\"U\":\"https://link.springer.com/content/pdf/10.1007%2F978-3-319-20233-4_10.pdf\"},{\"Ty\":3,\"U\":\"https://rd.springer.com/content/pdf/10.1007%2F978-3-319-20233-4_10.pdf\"},{\"Ty\":1,\"U\":\"https://link.springer.com/chapter/10.1007%2F978-3-319-20233-4_10\"}],\"VFN\":\"Workshop on Big Data Benchmarks\",\"FP\":101,\"LP\":108,\"DOI\":\"10.1007/978-3-319-20233-4_10\",\"PR\":[1987785403,175221152,1555823722,1538469196,624366154,2183930450,2621021030,2007002790,2309069030,2888937027,1931705586,2575198900,2791947637,2890951016,2124819012,87526489,1579107606,1485400967,1481755037,2801169824,1987785403,175221152,1555823722,1538469196,624366154,2183930450,2621021030,2007002790,2309069030,2888937027,1931705586,2575198900,2791947637,2890951016,2124819012,87526489,1579107606,1485400967,1481755037,2801169824],\"ANF\":[{\"FN\":\"Ralf\",\"LN\":\"Teusner\",\"S\":1},{\"FN\":\"Michael\",\"LN\":\"Perscheid\",\"S\":2},{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":3},{\"FN\":\"Jonas\",\"LN\":\"Enderlein\",\"S\":4},{\"FN\":\"Thomas\",\"LN\":\"Klingbeil\",\"S\":5},{\"FN\":\"Michael\",\"LN\":\"Kusber\",\"S\":6}],\"BV\":\"Workshop on Big Data Benchmarks\",\"BT\":\"a\",\"PB\":\"Springer International Publishing\"}"},{"logprob":-24.388,"Id":2342859941,"Ty":"0","Ti":"science of computer programming","Pt":"0","Y":2010,"D":"2010-01-01","CC":0,"ECC":0,"RId":[2138363365,2143238865,2014309790,2075642720,2150275961,2172147300,2129063689,2045723688,1992443356,2065646798,2111898165,2115680394,2076638640,2144114063,2157920816,2089889705,1964757858,2154597770,2115607078,2087175184,1527077815,1556513858,1602100009,2014881790,2166901142,2115899208,2032415879,2089794420,2101876886,1529505352,2002568360,1482265802,140370410],"W":["computer","programming","science"],"AA":[{"DAuN":"Jens Lincke","AuN":"jens lincke","AuId":2055148755,"S":1},{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":135591984,"S":2},{"DAuN":"Bastian Steinert","AuN":"bastian steinert","AuId":2142371068,"S":3},{"DAuN":"Robert Hirschfeld","AuN":"robert hirschfeld","AuId":2154319088,"S":4}],"F":[{"DFN":"Open implementation","FN":"open implementation","FId":2781022897},{"DFN":"Distributed computing","FN":"distributed computing","FId":120314980},{"DFN":"Control flow","FN":"control flow","FId":160191386},{"DFN":"Constructed language","FN":"constructed language","FId":94922259},{"DFN":"Computer science","FN":"computer science","FId":41008148},{"DFN":"Computer programming","FN":"computer programming","FId":33857546},{"DFN":"Abstraction","FN":"abstraction","FId":124304363}],"E":"{\"DN\":\"Science of Computer Programming\",\"IA\":{\"IndexLength\":148,\"InvertedIndex\":{\"Context-oriented\":[0],\"programming\":[1],\"(COP)\":[2],\"provides\":[3],\"dedicated\":[4],\"support\":[5],\"for\":[6,27,39,55,62,73,142],\"defining\":[7],\"and\":[8,58,113,136],\"composing\":[9],\"variations\":[10],\"to\":[11,81,98,110,117,121,145],\"a\":[12,22,32],\"basic\":[13],\"program\":[14],\"behavior.\":[15],\"A\":[16],\"variation,\":[17],\"which\":[18],\"is\":[19],\"defined\":[20],\"within\":[21],\"layer,\":[23],\"can\":[24,46,91],\"be\":[25,111,122],\"de-/activated\":[26],\"the\":[28,60,83,93,118,126],\"dynamic\":[29],\"extent\":[30],\"of\":[31,69,85,128],\"code\":[33],\"block.\":[34],\"While\":[35],\"this\":[36],\"mechanism\":[37],\"allows\":[38],\"control\":[40,50],\"flow-specific\":[41],\"scoping,\":[42],\"expressing\":[43],\"behavior\":[44,56],\"adaptations\":[45],\"demand\":[47],\"alternativescopes.Forinstance,adaptationscandependondynamicobjectstructurerather\":[48],\"than\":[49],\"flow.\":[51],\"We\":[52,79,124],\"present\":[53,137],\"scenarios\":[54],\"adaptation\":[57],\"identify\":[59],\"need\":[61],\"new\":[63,74,138],\"scoping\":[64,70,86,131,139],\"mechanisms.\":[65],\"The\":[66],\"increasing\":[67],\"number\":[68],\"mechanisms\":[71,87,132,140],\"calls\":[72],\"language\":[75,95],\"abstractions\":[76],\"representing\":[77],\"them.\":[78],\"suggest\":[80],\"open\":[82,103],\"implementation\":[84,104,127],\"so\":[88],\"that\":[89,115],\"developers\":[90],\"extend\":[92],\"COP\":[94,130],\"core\":[96],\"according\":[97],\"their\":[99],\"specific\":[100],\"needs.\":[101],\"Our\":[102],\"moves\":[105],\"layer\":[106],\"composition\":[107],\"into\":[108],\"objects\":[109],\"affected\":[112],\"with\":[114],\"closer\":[116],\"method\":[119],\"dispatch\":[120],\"changed.\":[123],\"discuss\":[125],\"established\":[129],\"using\":[133],\"our\":[134,143],\"approach\":[135],\"developed\":[141],\"enhancements\":[144],\"Lively\":[146],\"Kernel.\":[147]}},\"VFN\":\"\",\"PR\":[1978875190,2101760565,2470445784,1715370511,2294728544,1536560429,2165424958,2154705074,2884377853,2791760125,2132466790,1853781952,2181409250,1995931471,2168546524,2507470620,915208684,2211627941,2123124394,2728130927,1978875190,2101760565,2470445784,1715370511,2294728544,1536560429,2165424958,2154705074,2884377853,2791760125,2132466790,1853781952,2181409250,1995931471,2168546524,2507470620,915208684,2211627941,2123124394,2728130927],\"ANF\":[{\"FN\":\"Jens\",\"LN\":\"Lincke\",\"S\":1},{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":2},{\"FN\":\"Bastian\",\"LN\":\"Steinert\",\"S\":3},{\"FN\":\"Robert\",\"LN\":\"Hirschfeld\",\"S\":4}],\"BT\":\"a\"}"},{"logprob":-25.098,"Id":2614077473,"Ty":"0","Ti":"extending context oriented programming to new application domains run time adaptation support for java","Pt":"0","L":"en","Y":2012,"D":"2012-01-01","CC":0,"ECC":0,"W":["adaptation","application","context","domains","extending","java","oriented","programming","run","support","time"],"AA":[{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":2718042528,"S":1}],"F":[{"DFN":"strictfp","FN":"strictfp","FId":174954855},{"DFN":"Scala","FN":"scala","FId":109701466},{"DFN":"Real time Java","FN":"real time java","FId":132106392},{"DFN":"Programming language","FN":"programming language","FId":199360897},{"DFN":"Java concurrency","FN":"java concurrency","FId":181907185},{"DFN":"Java","FN":"java","FId":548217200},{"DFN":"Computer science","FN":"computer science","FId":41008148}],"E":"{\"DN\":\"Extending Context-oriented Programming to New Application Domains: Run-time Adaptation Support for Java\",\"S\":[{\"Ty\":1,\"U\":\"https://publishup.uni-potsdam.de/opus4-ubp/frontdoor/index/index/docId/32628\"}],\"VFN\":\"\",\"PR\":[2118908499,2885960218,2068290019,1638978760,1575441514,2133456356,2067307118,2165013282,2221858014,2060143662,405818308,1995410953,2157550035,1498054960,176558626,1557264844,2125219181,1479747945,1501853212,2095967962,2118908499,2885960218,2068290019,1638978760,1575441514,2133456356,2067307118,2165013282,2221858014,2060143662,405818308,1995410953,2157550035,1498054960,176558626,1557264844,2125219181,1479747945,1501853212,2095967962],\"ANF\":[{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":1}],\"BT\":\"a\"}"},{"logprob":-25.111,"Id":150730099,"Ty":"0","Ti":"gentl logic program transformation with concrete syntax","Pt":"0","Y":2007,"D":"2007-01-01","CC":0,"ECC":0,"RId":[1974001278,179823720],"W":["concrete","gentl","logic","program","syntax","transformation"],"AA":[{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":2796791905,"S":1},{"DAuN":"Gunter Kniesel","AuN":"gunter kniesel","AuId":729669163,"S":2},{"DAuN":"Daniel Speicher","AuN":"daniel speicher","AuId":1968284350,"S":3}],"F":[{"DFN":"Theoretical computer science","FN":"theoretical computer science","FId":80444323},{"DFN":"Syntax","FN":"syntax","FId":60048249},{"DFN":"Programming language","FN":"programming language","FId":199360897},{"DFN":"Program transformation","FN":"program transformation","FId":2778361913},{"DFN":"Logic programming","FN":"logic programming","FId":128838566},{"DFN":"Dynamic logic (modal logic)","FN":"dynamic logic","FId":137488015},{"DFN":"Description logic","FN":"description logic","FId":102993220},{"DFN":"Computer science","FN":"computer science","FId":41008148}],"E":"{\"DN\":\"GenTL: Logic Program Transformation with Concrete Syntax\",\"VFN\":\"\",\"PR\":[1593957878,2312610479,133519235,1964106726,2038821031,419072508,13994599,102536002,111585898,119847426,135873296,182261050,582340875,1976274827,1996042500,2003861878,2008913952,2323152351,2489854409,2491852988,1593957878,2312610479,133519235,1964106726,2038821031,419072508,13994599,102536002,111585898,119847426,135873296,182261050,582340875,1976274827,1996042500,2003861878,2008913952,2323152351,2489854409,2491852988],\"ANF\":[{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":1},{\"FN\":\"Gunter\",\"LN\":\"Kniesel\",\"S\":2},{\"FN\":\"Daniel\",\"LN\":\"Speicher\",\"S\":3}],\"BT\":\"a\"}"},{"logprob":-25.303,"Id":181189084,"Ty":"0","Ti":"declarative and event based context oriented programming","Pt":"0","L":"en","Y":2010,"D":"2010-01-01","CC":0,"ECC":0,"W":["context","declarative","event","oriented","programming"],"AA":[{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":301170490,"S":1}],"F":[{"DFN":"Programming paradigm","FN":"programming paradigm","FId":34165917},{"DFN":"Programming language","FN":"programming language","FId":199360897},{"DFN":"Programming domain","FN":"programming domain","FId":119263510},{"DFN":"Procedural programming","FN":"procedural programming","FId":120558287},{"DFN":"Inductive programming","FN":"inductive programming","FId":50033165},{"DFN":"First-generation programming language","FN":"first generation programming language","FId":570499},{"DFN":"Fifth-generation programming language","FN":"fifth generation programming language","FId":199305712},{"DFN":"Extensible programming","FN":"extensible programming","FId":131531359},{"DFN":"Declarative programming","FN":"declarative programming","FId":146206909},{"DFN":"Computer science","FN":"computer science","FId":41008148}],"E":"{\"DN\":\"declarative and event-based context-oriented programming\",\"VFN\":\"\",\"PR\":[1582280657,2571270951,797770425,5560624,151333322,2611345119,562223615,1206257515,173788665,2622531132,2593216387,114886242,1520473755,1489761424,2161563734,132032372,2368859544,159271714,2487622,2771637573,1582280657,2571270951,797770425,5560624,151333322,2611345119,562223615,1206257515,173788665,2622531132,2593216387,114886242,1520473755,1489761424,2161563734,132032372,2368859544,159271714,2487622,2771637573],\"ANF\":[{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":1}],\"BT\":\"a\"}"},{"logprob":-25.303,"Id":1592233759,"Ty":"0","Ti":"context oriented service computing","Pt":"0","Y":2010,"D":"2010-01-01","CC":0,"ECC":0,"W":["computing","context","oriented","service"],"AA":[{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":2636925436,"S":1}],"F":[{"DFN":"Utility computing","FN":"utility computing","FId":85106507},{"DFN":"Service level requirement","FN":"service level requirement","FId":23922727},{"DFN":"Service delivery framework","FN":"service delivery framework","FId":68595000},{"DFN":"Service catalog","FN":"service catalog","FId":189423186},{"DFN":"Grid computing","FN":"grid computing","FId":70429105},{"DFN":"Fabric computing","FN":"fabric computing","FId":66898733},{"DFN":"End-user computing","FN":"end user computing","FId":135642988},{"DFN":"Distributed computing","FN":"distributed computing","FId":120314980},{"DFN":"Data as a service","FN":"data as a service","FId":97300177},{"DFN":"Computer science","FN":"computer science","FId":41008148}],"E":"{\"DN\":\"Context-oriented Service Computing.\",\"S\":[{\"Ty\":1,\"U\":\"http://dblp.uni-trier.de/db/conf/dagstuhl/algosyn2010.html#Appeltauer10\"}],\"VFN\":\"AlgoSyn\",\"FP\":192,\"PR\":[2340358991,2495366324,138910063,100754910,2843199370,1547542187,172024257,12515770,182527507,1598921347,2586384438,2263759112,2565340940,79435808,109108704,2168904633,138360644,181141968,2157418168,1600018189,2340358991,2495366324,138910063,100754910,2843199370,1547542187,172024257,12515770,182527507,1598921347,2586384438,2263759112,2565340940,79435808,109108704,2168904633,138360644,181141968,2157418168,1600018189],\"ANF\":[{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":1}],\"BV\":\"AlgoSyn\",\"BT\":\"a\"}"},{"logprob":-25.509,"Id":100754910,"Ty":"0","Ti":"context oriented service development","Pt":"0","Y":2008,"D":"2008-01-01","CC":0,"ECC":0,"W":["context","development","oriented","service"],"AA":[{"DAuN":"Malte Appeltauer","AuN":"malte appeltauer","AuId":718795294,"S":1}],"F":[{"DFN":"Service system","FN":"service system","FId":15587899},{"DFN":"Service provider","FN":"service provider","FId":116537},{"DFN":"Service level requirement","FN":"service level requirement","FId":23922727},{"DFN":"Service design","FN":"service design","FId":61063171},{"DFN":"Service delivery framework","FN":"service delivery framework","FId":68595000},{"DFN":"Process management","FN":"process management","FId":195094911},{"DFN":"Customer Service Assurance","FN":"customer service assurance","FId":61974975},{"DFN":"Business","FN":"business","FId":144133560},{"DFN":"Application service provider","FN":"application service provider","FId":76143314}],"E":"{\"DN\":\"Context-oriented Service Development\",\"VFN\":\"\",\"PR\":[1592233759,2770046850,2395605620,2475728299,1511543899,2478957466,13904626,64204153,1547542187,2604312635,33782518,172024257,2500310139,12515770,35802165,138927141,182527507,1988725443,1985685407,10755900,1592233759,2770046850,2395605620,2475728299,1511543899,2478957466,13904626,64204153,1547542187,2604312635,33782518,172024257,2500310139,12515770,35802165,138927141,182527507,1988725443,1985685407,10755900],\"ANF\":[{\"FN\":\"Malte\",\"LN\":\"Appeltauer\",\"S\":1}],\"BT\":\"a\"}"}]}