Stefan-Marr.de | Recently Read

Recently Read

Research is much about reading, so here are publications listed I have recently read. This list is imported from my BibSonomy account.

[2011,inproceedings] bibtex

S. Sidiroglou-Douskos, S. Misailovic, H. Hoffmann, and M. Rinard, "Managing Performance vs. Accuracy Trade-offs With Loop Perforation," in Proceedings of the 19th ACM SIGSOFT symposium and the 13th European conference on Foundations of software engineering, New York, NY, USA, 2011, pp. 124-134.

@inproceedings{Sidiroglou-Douskos:2011:MPV:2025113.2025133, abstract = {Many modern computations (such as video and audio encoders, Monte Carlo simulations, and machine learning algorithms) are designed to trade off accuracy in return for increased performance. To date, such computations typically use ad-hoc, domain-specific techniques developed specifically for the computation at hand. Loop perforation provides a general technique to trade accuracy for performance by transforming loops to execute a subset of their iterations. A criticality testing phase filters out critical loops (whose perforation produces unacceptable behavior) to identify tunable loops (whose perforation produces more efficient and still acceptably accurate computations). A perforation space exploration algorithm perforates combinations of tunable loops to find Pareto-optimal perforation policies. Our results indicate that, for a range of applications, this approach typically delivers performance increases of over a factor of two (and up to a factor of seven) while changing the result that the application produces by less than 10%.}, acmid = {2025133}, added-at = {2012-01-30T17:41:50.000+0100}, address = {New York, NY, USA}, author = {Sidiroglou-Douskos, Stelios and Misailovic, Sasa and Hoffmann, Henry and Rinard, Martin}, biburl = {http://www.bibsonomy.org/bibtex/22d6df7f7fdf8a343604dfe8307fb4a4f/gron}, booktitle = {Proceedings of the 19th ACM SIGSOFT symposium and the 13th European conference on Foundations of software engineering}, description = {Managing performance vs. accuracy trade-offs with loop perforation}, doi = {10.1145/2025113.2025133}, interhash = {10d3dce72c5a609db140762f08f7ab88}, intrahash = {2d6df7f7fdf8a343604dfe8307fb4a4f}, isbn = {978-1-4503-0443-6}, keywords = {approximate holes loop non-deterministic}, location = {Szeged, Hungary}, numpages = {11}, pages = {124--134}, publisher = {ACM}, series = {ESEC/FSE '11}, timestamp = {2012-01-30T17:41:50.000+0100}, title = {Managing Performance vs. Accuracy Trade-offs With Loop Perforation}, url = {http://doi.acm.org/10.1145/2025113.2025133}, year = 2011 }
[2008,inproceedings] bibtex

X. Liu, Z. Guo, X. Wang, F. Chen, X. Lian, J. Tang, M. Wu, F. M. Kaashoek, and Z. Zhang, "D3S: debugging deployed distributed systems," in Proceedings of the 5th USENIX Symposium on Networked Systems Design and Implementation, Berkeley, CA, USA, 2008, pp. 423-437.

@inproceedings{Liu:2008:DSD:1387589.1387619, abstract = {Testing large-scale distributed systems is a challenge, because some errors manifest themselves only after a distributed sequence of events that involves machine and network failures. D³S is a checker that allows developers to specify predicates on distributed properties of a deployed system, and that checks these predicates while the system is running. When D³S finds a problem it produces the sequence of state changes that led to the problem, allowing developers to quickly find the root cause.
Developers write predicates in a simple and sequential programming style, while D³S checks these predicates in a distributed and parallel manner to allow checking to be scalable to large systems and fault tolerant. By using binary instrumentation, D³S works transparently with legacy systems and can change predicates to be checked at runtime. An evaluation with 5 deployed systems shows that D³S can detect non-trivial correctness and performance bugs at runtime and with low performance overhead (less than 8%).}, acmid = {1387619}, added-at = {2012-01-30T13:02:26.000+0100}, address = {Berkeley, CA, USA}, author = {Liu, Xuezheng and Guo, Zhenyu and Wang, Xi and Chen, Feibo and Lian, Xiaochen and Tang, Jian and Wu, Ming and Kaashoek, M. Frans and Zhang, Zheng}, biburl = {http://www.bibsonomy.org/bibtex/2b3b3e951f098753990e15e8fb40107f3/gron}, booktitle = {Proceedings of the 5th USENIX Symposium on Networked Systems Design and Implementation}, description = {D3S}, interhash = {bda13f274f7eb3e05d878021c75e67e4}, intrahash = {b3b3e951f098753990e15e8fb40107f3}, isbn = {111-999-5555-22-1}, keywords = {debugging distributed}, location = {San Francisco, California}, numpages = {15}, pages = {423--437}, publisher = {USENIX Association}, series = {NSDI'08}, timestamp = {2012-01-30T13:02:26.000+0100}, title = {D3S: debugging deployed distributed systems}, url = {http://dl.acm.org/citation.cfm?id=1387589.1387619}, year = 2008 }
[2006,inproceedings] bibtex

D. Geels, G. Altekar, S. Shenker, and I. Stoica, "Replay debugging for distributed applications," in Proceedings of the annual conference on USENIX ’06 Annual Technical Conference, Berkeley, CA, USA, 2006, pp. 289-300.

@inproceedings{Geels:2006:RDD:1267359.1267386, abstract = {We have developed a new replay debugging tool, liblog, for distributed C/C++ applications. It logs the execution of deployed application processes and replays them deterministically, faithfully reproducing race conditions and non-deterministic failures, enabling careful offline analysis. To our knowledge, liblog is the first replay tool to address the requirements of large distributed systems: lightweight support for long-running programs, consistent replay of arbitrary subsets of application nodes, and operation in a mixed environment of logging and nonlogging processes. In addition, it requires no special hardware or kernel patches, supports unmodified application executables, and integrates GDB into the replay mechanism for simultaneous source-level debugging of multiple processes.
This paper presents liblog's design, an evaluation of its runtime overhead, and a discussion of our experience with the tool to date.}, acmid = {1267386}, added-at = {2012-01-30T13:00:31.000+0100}, address = {Berkeley, CA, USA}, author = {Geels, Dennis and Altekar, Gautam and Shenker, Scott and Stoica, Ion}, biburl = {http://www.bibsonomy.org/bibtex/21f66b48964f0af0aa727edd8a1ea0481/gron}, booktitle = {Proceedings of the annual conference on USENIX '06 Annual Technical Conference}, description = {Replay debugging for distributed applications}, interhash = {4976f0069cbf161f185748da1af6b4b8}, intrahash = {1f66b48964f0af0aa727edd8a1ea0481}, keywords = {debugging distributed}, location = {Boston, MA}, numpages = {1}, pages = {289--300}, publisher = {USENIX Association}, timestamp = {2012-01-30T13:00:31.000+0100}, title = {Replay debugging for distributed applications}, url = {http://dl.acm.org/citation.cfm?id=1267359.1267386}, year = 2006 }
[2012,inproceedings] bibtex

S. Marr, J. Nicolay, T. Van Cutsem, and T. D’Hondt, "Modularity and Conventions for Maintainable Concurrent Language Implementations: A Review of Our Experiences and Practices," in Proceedings of the 2nd Workshop on Modularity In Systems Software (MISS’2012), 2012.

@inproceedings{MISS2012, abstract = {In this paper, we review what we have learned from implementing languages for parallel and concurrent programming, and investigate the role of modularity. To identify the approaches used to facilitate correctness and maintainability, we ask the following questions: What guides modularization? Are informal approaches used to facilitate correctness? Are concurrency concerns modularized? And, where is language support lacking most? Our subjects are AmbientTalk, SLIP, and the RoarVM. All three evolved over the years, enabling us to look back at specific experiments to understand the impact of concurrency on modularity. We conclude from our review that concurrency concerns are one of the strongest drivers for the definition of module boundaries. It helps when languages offer sophisticated modularization constructs. However, with respect to concurrency, other language features like single-assignment are of greater importance. Furthermore, tooling that enables remodularization taking concurrency invariants into account would be of great value.}, added-at = {2012-01-24T12:25:07.000+0100}, author = {Marr, Stefan and Nicolay, Jens and Van Cutsem, Tom and D'Hondt, Theo}, biburl = {http://www.bibsonomy.org/bibtex/2442f0063842536e3628d10a4244620b6/gron}, booktitle = {Proceedings of the 2nd Workshop on Modularity In Systems Software (MISS'2012)}, interhash = {f6aa985b183f15b014127ac282ce73d5}, intrahash = {442f0063842536e3628d10a4244620b6}, keywords = {CaseStudy Concurrency ExperienceReport Interpreters MeMyPublication Modularity Parallelism VMs myown}, month = {March}, note = {(to appear)}, publisher = {ACM}, series = {MISS'12}, timestamp = {2012-01-24T12:25:07.000+0100}, title = {Modularity and Conventions for Maintainable Concurrent Language Implementations: A Review of Our Experiences and Practices}, year = 2012 }
[2011,article] bibtex

A. Sampson, W. Dietl, E. Fortuna, D. Gnanapragasam, L. Ceze, and D. Grossman, "EnerJ: Approximate Data Types for Safe and General Low-Power Computation," SIGPLAN Not., vol. 46, pp. 164-174, 2011.

@article{Sampson:2011:EAD:1993316.1993518, acmid = {1993518}, added-at = {2012-01-23T16:17:34.000+0100}, address = {New York, NY, USA}, author = {Sampson, Adrian and Dietl, Werner and Fortuna, Emily and Gnanapragasam, Danushen and Ceze, Luis and Grossman, Dan}, biburl = {http://www.bibsonomy.org/bibtex/2b8a7c7aac46054bf2172e51ccea0bf21/gron}, description = {EnerJ}, doi = {10.1145/1993316.1993518}, interhash = {5e3ab347463aea9a26f2218c54da58e2}, intrahash = {b8a7c7aac46054bf2172e51ccea0bf21}, issn = {0362-1340}, issue = {6}, issue_date = {June 2011}, journal = {SIGPLAN Not.}, keywords = {TypeSystem efficiency energy java low non-deterministic power}, month = {June}, numpages = {11}, pages = {164--174}, publisher = {ACM}, timestamp = {2012-01-23T16:17:34.000+0100}, title = {EnerJ: Approximate Data Types for Safe and General Low-Power Computation}, url = {http://doi.acm.org/10.1145/1993316.1993518}, volume = 46, year = 2011 }
[2011,inproceedings] bibtex

J. Triplett, P. E. McKenney, and J. Walpole, "Resizable, Scalable, Concurrent Hash Tables via Relativistic Programming," in Proceedings of the 2011 USENIX conference on USENIX annual technical conference, Berkeley, CA, USA, 2011, p. 11.

@inproceedings{Triplett:2011:RSC:2002181.2002192, abstract = {We present algorithms for shrinking and expanding a hash table while allowing concurrent, wait-free, linearly scalable lookups. These resize algorithms allow Read-Copy Update (RCU) hash tables to maintain constant-time performance as the number of entries grows, and reclaim memory as the number of entries decreases, without delaying or disrupting readers. We call the resulting data structure a relativistic hash table. Benchmarks of relativistic hash tables in the Linux kernel show that lookup scalability during resize improves 125x over reader-writer locking, and 56% over Linux's current state of the art. Relativistic hash lookups experience no performance degradation during a resize. Applying this algorithm to memcached removes a scalability limit for get requests, allowing memcached to scale linearly and service up to 46% more requests per second.
Relativistic hash tables demonstrate the promise of a new concurrent programming methodology known as relativistic programming. Relativistic programming makes novel use of existing RCU synchronization primitives, namely the wait-for-readers operation that waits for unfinished readers to complete. This operation, conventionally used to handle reclamation, here allows ordering of updates without read-side synchronization or memory barriers.}, acmid = {2002192}, added-at = {2012-01-23T15:32:09.000+0100}, address = {Berkeley, CA, USA}, author = {Triplett, Josh and McKenney, Paul E. and Walpole, Jonathan}, biburl = {http://www.bibsonomy.org/bibtex/22901f41af59c26c028beab65c179d593/gron}, booktitle = {Proceedings of the 2011 USENIX conference on USENIX annual technical conference}, description = {Resizable, scalable, concurrent hash tables via relativistic programming}, interhash = {e3865bed6dcb48bdc77e154a1efb39f6}, intrahash = {2901f41af59c26c028beab65c179d593}, keywords = {hash non-deterministic relativistic table}, location = {Portland, OR}, numpages = {1}, pages = 11, publisher = {USENIX Association}, series = {USENIXATC'11}, timestamp = {2012-01-23T15:32:09.000+0100}, title = {Resizable, Scalable, Concurrent Hash Tables via Relativistic Programming}, url = {http://dl.acm.org/citation.cfm?id=2002181.2002192}, year = 2011 }
[1976,article] bibtex

M. M. Astrahan, M. W. Blasgen, D. D. Chamberlin, K. P. Eswaran, J. N. Gray, P. P. Griffiths, W. F. King, R. A. Lorie, P. R. McJones, J. W. Mehl, G. R. Putzolu, I. L. Traiger, B. W. Wade, and V. Watson, "System R: Relational Approach to Database Management," ACM Trans. Database Syst., vol. 1, pp. 97-137, 1976.

@article{Astrahan:1976:SRR:320455.320457, acmid = {320457}, added-at = {2012-01-23T14:16:29.000+0100}, address = {New York, NY, USA}, author = {Astrahan, M. M. and Blasgen, M. W. and Chamberlin, D. D. and Eswaran, K. P. and Gray, J. N. and Griffiths, P. P. and King, W. F. and Lorie, R. A. and McJones, P. R. and Mehl, J. W. and Putzolu, G. R. and Traiger, I. L. and Wade, B. W. and Watson, V.}, biburl = {http://www.bibsonomy.org/bibtex/2d501a6ed44dbf2e7ffeb25f05353f9db/gron}, description = {System R}, doi = {10.1145/320455.320457}, interhash = {1606f5269caee4d087b253b255f675f4}, intrahash = {d501a6ed44dbf2e7ffeb25f05353f9db}, issn = {0362-5915}, issue = {2}, journal = {ACM Trans. Database Syst.}, keywords = {consistency database level}, month = {June}, numpages = {41}, pages = {97--137}, publisher = {ACM}, timestamp = {2012-01-23T14:16:29.000+0100}, title = {System R: Relational Approach to Database Management}, url = {http://doi.acm.org/10.1145/320455.320457}, volume = 1, year = 1976 }
[2011,article] bibtex

M. Rys, "Scalable SQL," Commun. ACM, vol. 54, pp. 48-53, 2011.

@article{Rys:2011:SS:1953122.1953141, abstract = {How do large-scale sites and applications remain SQL-based?}, acmid = {1953141}, added-at = {2012-01-23T14:06:27.000+0100}, address = {New York, NY, USA}, author = {Rys, Michael}, biburl = {http://www.bibsonomy.org/bibtex/202a1d394ab16b52a8ea83e387c70101d/gron}, description = {Scalable SQL}, doi = {10.1145/1953122.1953141}, interhash = {264c46ed58eb311bc808685fd451df66}, intrahash = {02a1d394ab16b52a8ea83e387c70101d}, issn = {0001-0782}, issue = {6}, issue_date = {June 2011}, journal = {Commun. ACM}, keywords = {consistency data nosql races scalability}, month = jun, numpages = {6}, pages = {48--53}, publisher = {ACM}, timestamp = {2012-01-23T14:06:27.000+0100}, title = {Scalable SQL}, url = {http://doi.acm.org/10.1145/1953122.1953141}, volume = 54, year = 2011 }
[2010,article] bibtex

S. V. Adve and H. Boehm, "Memory Models: A Case for Rethinking Parallel Languages and Hardware," Commun. ACM, vol. 53, pp. 90-101, 2010.

@article{Adve:2010:MMC:1787234.1787255, abstract = {Solving the memory model problem will require an ambitious and cross-disciplinary research direction.}, acmid = {1787255}, added-at = {2012-01-23T13:54:38.000+0100}, address = {New York, NY, USA}, author = {Adve, Sarita V. and Boehm, Hans-J.}, biburl = {http://www.bibsonomy.org/bibtex/2937fe65bdfb28db7cdd103b93dac091a/gron}, description = {Memory models}, doi = {10.1145/1787234.1787255}, interhash = {10ac39188a5bcaef076864272874577d}, intrahash = {937fe65bdfb28db7cdd103b93dac091a}, issn = {0001-0782}, issue = {8}, issue_date = {August 2010}, journal = {Commun. ACM}, keywords = {c++ concurrency data hardware java non-determenism parallelism performance races}, month = aug, numpages = {12}, pages = {90--101}, publisher = {ACM}, timestamp = {2012-01-23T13:54:38.000+0100}, title = {Memory Models: A Case for Rethinking Parallel Languages and Hardware}, url = {http://doi.acm.org/10.1145/1787234.1787255}, volume = 53, year = 2010 }
[2010,article] bibtex

S. Adve, "Technical Perspective: Data Races are Evil with No Exceptions," Commun. ACM, vol. 53, p. 84, 2010.

@article{Adve:2010:DRE:1839676.1839697, acmid = {1839697}, added-at = {2012-01-23T13:12:59.000+0100}, address = {New York, NY, USA}, author = {Adve, Sarita}, biburl = {http://www.bibsonomy.org/bibtex/243001282c8489f7bc737cf6c3659ec92/gron}, doi = {10.1145/1839676.1839697}, interhash = {fc0c276cacb31e16a228ae65678f569e}, intrahash = {43001282c8489f7bc737cf6c3659ec92}, issn = {0001-0782}, issue = {11}, issue_date = {November 2010}, journal = {Commun. ACM}, keywords = {argument data non-determenism races}, month = nov, numpages = {1}, pages = 84, publisher = {ACM}, timestamp = {2012-01-23T13:12:59.000+0100}, title = {Technical Perspective: Data Races are Evil with No Exceptions}, url = {http://doi.acm.org/10.1145/1839676.1839697}, volume = 53, year = 2010 }
[2011,inproceedings] bibtex

T. Verwaest, C. Bruni, M. Lungu, and O. Nierstrasz, "Flexible Object Layouts: Enabling Lightweight Language Extensions by Intercepting Slot Access," in Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications, New York, NY, USA, 2011, pp. 959-972.

@inproceedings{Verwaest:2011:FOL:2048066.2048138, acmid = {2048138}, added-at = {2012-01-09T11:50:42.000+0100}, address = {New York, NY, USA}, author = {Verwaest, Toon and Bruni, Camillo and Lungu, Mircea and Nierstrasz, Oscar}, biburl = {http://www.bibsonomy.org/bibtex/24ddb77eb8f3b514cdce238a854ec9eda/gron}, booktitle = {Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications}, description = {Flexible object layouts}, doi = {10.1145/2048066.2048138}, interhash = {e2435f81d1cfdeb739f8f9d00d283079}, intrahash = {4ddb77eb8f3b514cdce238a854ec9eda}, isbn = {978-1-4503-0940-0}, keywords = {MOP Slots access customization object}, location = {Portland, Oregon, USA}, numpages = {14}, pages = {959--972}, publisher = {ACM}, series = {OOPSLA '11}, timestamp = {2012-01-09T11:50:42.000+0100}, title = {Flexible Object Layouts: Enabling Lightweight Language Extensions by Intercepting Slot Access}, url = {http://doi.acm.org/10.1145/2048066.2048138}, year = 2011 }
[2006,article] bibtex

T. Harris, M. Plesko, A. Shinnar, and D. Tarditi, "Optimizing Memory Transactions," SIGPLAN Not., vol. 41, pp. 14-25, 2006.

@article{Harris:2006:OMT:1133255.1133984, acmid = {1133984}, added-at = {2012-01-08T21:21:20.000+0100}, address = {New York, NY, USA}, author = {Harris, Tim and Plesko, Mark and Shinnar, Avraham and Tarditi, David}, biburl = {http://www.bibsonomy.org/bibtex/28ef31d5e8e4cdf4747aa401bb2cf0479/gron}, description = {Optimizing memory transactions}, doi = {10.1145/1133255.1133984}, interhash = {f11b5561f327fc4d6ed6d3a6f5877fbe}, intrahash = {8ef31d5e8e4cdf4747aa401bb2cf0479}, issn = {0362-1340}, issue = {6}, journal = {SIGPLAN Not.}, keywords = {.NET AOT CLR Compiler JIT STM VM compilation}, month = {June}, numpages = {12}, pages = {14--25}, publisher = {ACM}, timestamp = {2012-01-08T21:21:20.000+0100}, title = {Optimizing Memory Transactions}, url = {http://doi.acm.org/10.1145/1133255.1133984}, volume = 41, year = 2006 }
[2011,article] bibtex

K. J. Hoffman, H. Metzger, and P. Eugster, "Ribbons: A Partially Shared Memory Programming Model," SIGPLAN Not., vol. 46, pp. 289-306, 2011.

@article{Hoffman:2011:RPS:2076021.2048091, acmid = {2048091}, added-at = {2012-01-08T19:58:49.000+0100}, address = {New York, NY, USA}, author = {Hoffman, Kevin J. and Metzger, Harrison and Eugster, Patrick}, biburl = {http://www.bibsonomy.org/bibtex/2405ade28f06f8d0c92a8b78ce64be7b8/gron}, description = {Ribbons}, doi = {10.1145/2076021.2048091}, interhash = {235dc798ab4e0f121a6a2f3826c29a4d}, intrahash = {405ade28f06f8d0c92a8b78ce64be7b8}, issn = {0362-1340}, issue = {10}, issue_date = {October 2011}, journal = {SIGPLAN Not.}, keywords = {OS OperatingSystem Ribbons linux memory processes protection threads}, month = oct, numpages = {18}, pages = {289--306}, publisher = {ACM}, timestamp = {2012-01-08T19:58:49.000+0100}, title = {Ribbons: A Partially Shared Memory Programming Model}, url = {http://doi.acm.org/10.1145/2076021.2048091}, volume = 46, year = 2011 }
[2005,article] bibtex

J. Field and C. A. Varela, "Transactors: A Programming Model for Maintaining Globally Consistent Distributed State in Unreliable Environments," SIGPLAN Not., vol. 40, pp. 195-208, 2005.

@article{Field:2005:TPM:1047659.1040322, acmid = {1040322}, added-at = {2012-01-08T19:39:40.000+0100}, address = {New York, NY, USA}, author = {Field, John and Varela, Carlos A.}, biburl = {http://www.bibsonomy.org/bibtex/26b53bb3e66ede620679209cabbfa373d/gron}, description = {Transactors}, doi = {10.1145/1047659.1040322}, interhash = {9e03cd5098562331d4ef45b55745c06e}, intrahash = {6b53bb3e66ede620679209cabbfa373d}, issn = {0362-1340}, issue = {1}, journal = {SIGPLAN Not.}, keywords = {Actors Concurrency Distribution Transaction}, month = {January}, numpages = {14}, pages = {195--208}, publisher = {ACM}, timestamp = {2012-01-08T19:39:40.000+0100}, title = {Transactors: A Programming Model for Maintaining Globally Consistent Distributed State in Unreliable Environments}, url = {http://doi.acm.org/10.1145/1047659.1040322}, volume = 40, year = 2005 }
[2010,inproceedings] bibtex

C. Thalinger and J. Rose, "Optimizing Invokedynamic," in Proceedings of the 8th International Conference on the Principles and Practice of Programming in Java, New York, NY, USA, 2010, pp. 1-9.

@inproceedings{Thalinger:2010:OI:1852761.1852763, abstract = {In order to support the needs of non-Java languages, the JSR 292 Expert Group has designed a new bytecode "invokedynamic" which allows JVM bytecodes to contain call sites with pluggable, user-defined behavior. The bytecode is accompanied by a new data type called a "method handle" that reifies the pluggable behavior, in the form of a functional value. The authors have been building the JSR 292 Reference Implementation on top of Oracle's HotSpot JVM. This paper describes their implementation tactics. Interesting subtopics include connecting the novel features of JSR 292 to classic HotSpot optimizations, creating new code optimization techniques for HotSpot in support of JSR 292, using Java (along with HotSpot's customary C++) as an implementation language for method handles, using internally-generated bytecodes as an intermediate language for "freezing" dynamic call sites before optimization, and designing specialized "adapter" calling sequences which match callers and callees of differing type descriptors.}, acmid = {1852763}, added-at = {2012-01-08T18:30:41.000+0100}, address = {New York, NY, USA}, author = {Thalinger, Christian and Rose, John}, biburl = {http://www.bibsonomy.org/bibtex/2aa93a23f8c8b7125436fc93642f0c48c/gron}, booktitle = {Proceedings of the 8th International Conference on the Principles and Practice of Programming in Java}, description = {Optimizing invokedynamic}, doi = {10.1145/1852761.1852763}, interhash = {eb1a1d8f6a81e54a69c3a7ba51c19b22}, intrahash = {aa93a23f8c8b7125436fc93642f0c48c}, isbn = {978-1-4503-0269-2}, keywords = {JVM Java dynamic invokedynamic languages optimization}, location = {Vienna, Austria}, numpages = {9}, pages = {1--9}, publisher = {ACM}, series = {PPPJ '10}, timestamp = {2012-01-08T18:30:41.000+0100}, title = {Optimizing Invokedynamic}, url = {http://doi.acm.org/10.1145/1852761.1852763}, year = 2010 }
[2010,inproceedings] bibtex

T. Van Cutsem and M. S. Miller, "Proxies: Design Principles for Robust Object-oriented Intercession APIs," in Proceedings of the 6th symposium on Dynamic languages, New York, NY, USA, 2010, pp. 59-72.

@inproceedings{VanCutsem:2010:PDP:1899661.1869638, abstract = {Proxies are a powerful approach to implement meta-objects in object-oriented languages without having to resort to metacircular interpretation. We introduce such a meta-level API based on proxies for Javascript. We simultaneously introduce a set of design principles that characterize such APIs in general, and compare similar APIs of other languages in terms of these principles. We highlight how principled proxy-based APIs improve code robustness by avoiding interference between base and meta-level code that occur in more common reflective intercession mechanisms.}, acmid = {1869638}, added-at = {2012-01-07T18:25:03.000+0100}, address = {New York, NY, USA}, author = {Van Cutsem, Tom and Miller, Mark S.}, biburl = {http://www.bibsonomy.org/bibtex/2fd9c45a34c8a5f36887eb6aac9a00a12/gron}, booktitle = {Proceedings of the 6th symposium on Dynamic languages}, doi = {10.1145/1899661.1869638}, interhash = {24af65e87bcbbdeb5bf19a98b397e608}, intrahash = {fd9c45a34c8a5f36887eb6aac9a00a12}, issn = {0362-1340}, issue = {12}, issue_date = {December 2010}, keywords = {Javascript intercession mirrors proxies reflection stratification}, month = {October}, numpages = {14}, pages = {59--72}, publisher = {ACM}, series = {DLS '10}, timestamp = {2012-01-07T18:25:03.000+0100}, title = {Proxies: Design Principles for Robust Object-oriented Intercession APIs}, url = {http://doi.acm.org/10.1145/1899661.1869638}, year = 2010 }
[2009,conference] bibtex

C. Drummond, "Replicability in not Reproducibility: Nor is it Good Science," in The 4th workshop on Evaluation Methods for Machine Learning, Montreal, Canada, 2009.

@conference{Replicability, abstract = {At various machine learning conferences, at various times, there have been discussions arising from the inability to replicate the experimental result published in a paper. There seems to be a wide spread view that we need to do something to address this problem, as it is essential to the advancement of our field. The most compelling argument would seem to be that reproducibility of experimental results is the hallmark of science. Therefore, given that most of us regard machine learning as a scientific discipline, being able to replicate experiments is paramount. I want to challenge this view by separating the notion of reproducibility, a generally desirable property, from replicability, its poor cousin. I claim there are important differences between the two. Reproducibility requires changes; replicability avoids them. Although reproducibility is desirable, I contend that the impoverished version, replicability, is one not worth having.}, added-at = {2012-01-05T12:37:49.000+0100}, address = {Montreal, Canada}, author = {Drummond, Chris}, biburl = {http://www.bibsonomy.org/bibtex/2dc8ebafcf3ff94d41a8099d6ad0c2df2/gron}, booktitle = {The 4th workshop on Evaluation Methods for Machine Learning}, interhash = {5642662dcad3b70c2f08535ba9695b37}, intrahash = {dc8ebafcf3ff94d41a8099d6ad0c2df2}, keywords = {Experiments Replicability Science Value}, month = {06/2009}, timestamp = {2012-01-05T12:37:49.000+0100}, title = {Replicability in not Reproducibility: Nor is it Good Science}, url = {http://www.site.uottawa.ca/ICML09WS/papers/w2.pdf}, year = 2009 }
[1991,book] bibtex

G. Kiczales, J. des Rivières, and D. G. Bobrow, The Art of the Metaobject Protocol, Cambridge: The MIT Press, 1991.

@book{MOP, added-at = {2011-12-28T10:37:30.000+0100}, address = {Cambridge}, author = {Kiczales, Gregor and des Rivières, Jim and Bobrow, Daniel G.}, biburl = {http://www.bibsonomy.org/bibtex/224a9fdc6698d2c81e55d9311ab87acfd/gron}, description = {Amazon.com: The Art of the Metaobject Protocol (9780262610742): Gregor Kiczales, Jim des Rivieres, Daniel G. Bobrow: Books}, interhash = {c012931a2e10b3c157101281c84aa0ed}, intrahash = {24a9fdc6698d2c81e55d9311ab87acfd}, isbn = {0262610744 9780262610742 0262111586 9780262111584}, keywords = {CLOS Lisp MOP MetaProgramming}, publisher = {The MIT Press}, refid = {600858494}, timestamp = {2011-12-28T10:37:30.000+0100}, title = {The Art of the Metaobject Protocol}, url = {http://www.worldcat.org/search?qt=worldcat_org_all&q=0262610744}, year = 1991 }
[2010,article] bibtex

C. Herzeel and P. Costanza, "Dynamic parallelization of recursive code: part 1: managing control flow interactions with the continuator," SIGPLAN Not., vol. 45, pp. 377-396, 2010.

@article{Herzeel:2010:DPR:1932682.1869491, acmid = {1869491}, added-at = {2011-12-27T17:35:05.000+0100}, address = {New York, NY, USA}, author = {Herzeel, Charlotte and Costanza, Pascal}, biburl = {http://www.bibsonomy.org/bibtex/290537b1266e8e007cfd7857a97c94b55/gron}, description = {Dynamic parallelization of recursive code}, doi = {10.1145/1932682.1869491}, interhash = {b1b4521ff127bec1e79e10a40e6a53ec}, intrahash = {90537b1266e8e007cfd7857a97c94b55}, issn = {0362-1340}, issue = {10}, issue_date = {October 2010}, journal = {SIGPLAN Not.}, keywords = {Automatic Continuators Dynamic Language Parallelization}, month = {October}, numpages = {20}, pages = {377--396}, publisher = {ACM}, timestamp = {2011-12-27T17:35:05.000+0100}, title = {Dynamic parallelization of recursive code: part 1: managing control flow interactions with the continuator}, url = {http://doi.acm.org/10.1145/1932682.1869491}, volume = 45, year = 2010 }
[2008,inproceedings] bibtex

B. Morandi, S. S. Bauer, and B. Meyer, "SCOOP – A Contract-Based Concurrent Object-Oriented Programming Model," in Advanced Lectures on Software Engineering, LASER Summer School 2007/2008, 2008, pp. 41-90.

@inproceedings{MorandiBM08, added-at = {2011-12-26T19:00:37.000+0100}, author = {Morandi, Benjamin and Bauer, Sebastian S. and Meyer, Bertrand}, biburl = {http://www.bibsonomy.org/bibtex/22e92ca123a239f428b5e43be6c14829d/gron}, booktitle = {Advanced Lectures on Software Engineering, LASER Summer School 2007/2008}, citedby = {0}, cites = {0}, doi = {http://dx.doi.org/10.1007/978-3-642-13010-6_3}, editor = {Müller, Peter}, interhash = {fa63bbf3963887108c1937b7f921382c}, intrahash = {2e92ca123a239f428b5e43be6c14829d}, isbn = {978-3-642-13009-0}, keywords = {Concurrency Contracts Eiffel}, pages = {41-90}, publisher = {Springer}, researchr = {http://researchr.org/publication/MorandiBM08}, series = {Lecture Notes in Computer Science}, tags = {object-oriented programming, programming}, timestamp = {2011-12-26T19:00:37.000+0100}, title = {SCOOP - A Contract-Based Concurrent Object-Oriented Programming Model}, volume = 6029, year = 2008 }

Recently Read

Recent Posts

Twitter @smarr

Stefan Marr, PhD Student

Archive

Previous Posts

Modularity and Conventions for Maintainable Concurrent Language Implementations: A Review of Our Experiences and Practices

CSOM/PL: A Virtual Machine Product Line

Synchronization Views for Event-loop Actors