@conference {14701,
	title = {Improving software quality with static analysis},
	booktitle = {Proceedings of the 7th ACM SIGPLAN-SIGSOFT workshop on Program analysis for software tools and engineering},
	series = {PASTE {\textquoteright}07},
	year = {2007},
	month = {2007///},
	pages = {83 - 84},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {At the University of Maryland, we have been working to improve the reliability and security of software by developing new, effective static analysis tools. These tools scan software for bug patterns or show that the software is free from a particular class of defects. There are two themes common to our different projects: 1. Our ultimate focus is on utility: can a programmer actually improve the quality of his or her software using an analysis tool? The important first step toward answering this question is to engineer tools so that they can analyze existing, nontrivial programs, and to carefully report the results of such analyses experimentally. The desire to better understand a more human-centered notion of utility underlies much of our future work. 2. We release all of our tools open source. This allows other researchers to verify our results, and to reuse some or all of our implementations, which often required significant effort to engineer. We believe that releasing source code is important for accelerating the pace of research results software quality, and just as importantly allows feedback from the wider community. In this research group presentation, we summarize some recent work and sketch future directions.},
	keywords = {bug patterns, bugs, C, Data races, FFIs, java, modularity, network protocols, Software quality},
	isbn = {978-1-59593-595-3},
	doi = {10.1145/1251535.1251549},
	url = {http://doi.acm.org/10.1145/1251535.1251549},
	author = {Foster, Jeffrey S. and Hicks, Michael W. and Pugh, William}
}
@article {14680,
	title = {Dynamic inference of polymorphic lock types},
	journal = {Science of Computer Programming},
	volume = {58},
	year = {2005},
	month = {2005/12//},
	pages = {366 - 383},
	abstract = {We present FindLocks, an approach for automatically proving the absence of data races in multi-threaded Java programs, using a combination of dynamic and static analysis. The program in question is instrumented so that when executed it will gather information about locking relationships. This information is then used to automatically generate annotations needed to type check the program using the Race-Free Java type system. Programs that type check are sure to be free from races. We call this technique dynamic annotation inference. We describe the design and implementation of our approach, and our experience applying the tool to a variety of Java programs. We have found that when using a reasonably comprehensive test suite, which is easy for small programs but harder for larger ones, the approach generates useful annotations.},
	keywords = {Data races, Dynamic analysis, java, Multithreading, Type inference},
	isbn = {0167-6423},
	doi = {10.1016/j.scico.2005.03.003},
	url = {http://www.sciencedirect.com/science/article/pii/S0167642305000705},
	author = {Rose,James and Swamy,Nikhil and Hicks, Michael W.}
}
@conference {16384,
	title = {The Java memory model},
	booktitle = {Proceedings of the 32nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages},
	series = {POPL {\textquoteright}05},
	year = {2005},
	month = {2005///},
	pages = {378 - 391},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {This paper describes the new Java memory model, which has been revised as part of Java 5.0. The model specifies the legal behaviors for a multithreaded program; it defines the semantics of multithreaded Java programs and partially determines legal implementations of Java virtual machines and compilers.The new Java model provides a simple interface for correctly synchronized programs -- it guarantees sequential consistency to data-race-free programs. Its novel contribution is requiring that the behavior of incorrectly synchronized programs be bounded by a well defined notion of causality. The causality requirement is strong enough to respect the safety and security properties of Java and weak enough to allow standard compiler and hardware optimizations. To our knowledge, other models are either too weak because they do not provide for sufficient safety/security, or are too strong because they rely on a strong notion of data and control dependences that precludes some standard compiler transformations.Although the majority of what is currently done in compilers is legal, the new model introduces significant differences, and clearly defines the boundaries of legal transformations. For example, the commonly accepted definition for control dependence is incorrect for Java, and transformations based on it may be invalid.In addition to providing the official memory model for Java, we believe the model described here could prove to be a useful basis for other programming languages that currently lack well-defined models, such as C++ and C$\#$.},
	keywords = {concurrency, java, memory model, Multithreading},
	isbn = {1-58113-830-X},
	doi = {10.1145/1040305.1040336},
	url = {http://doi.acm.org/10.1145/1040305.1040336},
	author = {Manson,Jeremy and Pugh, William and Adve,Sarita V.}
}
@conference {14749,
	title = {Transparent proxies for java futures},
	booktitle = {Proceedings of the 19th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications},
	series = {OOPSLA {\textquoteright}04},
	year = {2004},
	month = {2004///},
	pages = {206 - 223},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {A proxy object is a surrogate or placeholder that controls access to another target object. Proxies can be used to support distributed programming, lazy or parallel evaluation, access control, and other simple forms of behavioral reflection. However, wrapper proxies (like futures or suspensions> for yet-to-be-computed results) can require significant code changes to be used in statically-typed languages, while proxies more generally can inadvertently violate assumptions of transparency, resulting in subtle bugs. To solve these problems, we have designed and implemented a simple framework for proxy programming that employs a static analysis based on qualifier inference, but with additional novelties. Code for using wrapper proxies is automatically introduced via a classfile-to-classfile transformation, and potential violations of transparency are signaled to the programmer. We have formalized our analysis and proven it sound. Our framework has a variety of applications, including support for asynchronous method calls returning futures. Experimental results demonstrate the benefits of our framework: programmers are relieved of managing and/or checking proxy usage, analysis times are reasonably fast, overheads introduced by added dynamic checks are negligible, and performance improvements can be significant. For example, changing two lines in a simple RMI-based peer-to-peer application and then using our framework resulted in a large performance gain.},
	keywords = {future, java, proxy, Type inference, type qualifier},
	isbn = {1-58113-831-8},
	doi = {10.1145/1028976.1028994},
	url = {http://doi.acm.org/10.1145/1028976.1028994},
	author = {Pratikakis,Polyvios and Spacco,Jaime and Hicks, Michael W.}
}
@article {17849,
	title = {The virtual microscope},
	journal = {IEEE Transactions on Information Technology in Biomedicine},
	volume = {7},
	year = {2003},
	month = {2003/12//},
	pages = {230 - 248},
	abstract = {We present the design and implementation of the virtual microscope, a software system employing a client/server architecture to provide a realistic emulation of a high power light microscope. The system provides a form of completely digital telepathology, allowing simultaneous access to archived digital slide images by multiple clients. The main problem the system targets is storing and processing the extremely large quantities of data required to represent a collection of slides. The virtual microscope client software runs on the end user{\textquoteright}s PC or workstation, while database software for storing, retrieving and processing the microscope image data runs on a parallel computer or on a set of workstations at one or more potentially remote sites. We have designed and implemented two versions of the data server software. One implementation is a customization of a database system framework that is optimized for a tightly coupled parallel machine with attached local disks. The second implementation is component-based, and has been designed to accommodate access to and processing of data in a distributed, heterogeneous environment. We also have developed caching client software, implemented in Java, to achieve good response time and portability across different computer platforms. The performance results presented show that the Virtual Microscope systems scales well, so that many clients can be adequately serviced by an appropriately configured data server.},
	keywords = {biomedical optical imaging, client software, client/server architecture, Computer architecture, Computer Graphics, computer platforms, Computer simulation, Concurrent computing, configured data server, data server software, database management systems, database software, Database systems, digital slide images, digital telepathology, diseases, emulation, Environment, Equipment Design, Equipment Failure Analysis, high power light microscope, Image databases, Image Enhancement, Image Interpretation, Computer-Assisted, Image retrieval, Information retrieval, Information Storage and Retrieval, java, local disks, microscope image data, Microscopy, multiple clients, optical microscopy, PACS, software, Software design, software system, Software systems, Systems Integration, Telepathology, User-Computer Interface, virtual microscope design, Virtual reality, Workstations},
	isbn = {1089-7771},
	doi = {10.1109/TITB.2004.823952},
	author = {Catalyurek,U. and Beynon,M. D and Chang,Chialin and Kurc, T. and Sussman, Alan and Saltz, J.}
}
@conference {14772,
	title = {Recompilation for debugging support in a JIT-compiler},
	booktitle = {Proceedings of the 2002 ACM SIGPLAN-SIGSOFT workshop on Program analysis for software tools and engineering},
	series = {PASTE {\textquoteright}02},
	year = {2002},
	month = {2002///},
	pages = {10 - 17},
	publisher = {ACM},
	organization = {ACM},
	address = {Charleston, South Carolina, USA},
	abstract = {A static Java compiler converts Java source code into a verifiably secure and compact architecture-neutral intermediate format, called Java byte codes. The Java byte codes can be either interpreted by a Java Virtual Machine or translated into native code by Java Just-In-Time compilers. Static Java compilers embed debug information in the Java class files to be used by the source level debuggers. However, the debug information is generated for architecture independent byte codes and most of the debug information is valid only when the byte codes are interpreted. Translating byte codes into native instructions puts a limitation on the amount of usable debug information that can be used by source level debuggers. In this paper, we present a new technique to generate valid debug information when Just-In-Time compilers are used. Our approach is based on the dynamic recompilation of Java methods by a fast code generator and lazily generates debug information when it is required. We also present three implementations for field watch support in the Java Virtual Machine Debugger Interface to investigate the runtime overhead and code size growth by our approach.},
	keywords = {algorithms, debug information, debugging aids, dynamic recompilation, field access watch, java, java virtual machine debugger interface, just-in-time compilation, measurement, performance},
	isbn = {1-58113-479-7},
	doi = {10.1145/586094.586100},
	author = {Tikir, Mustafa M. and Hollingsworth, Jeffrey K and Lueh,Guei-Yuan}
}
@conference {16779,
	title = {Integrating distributed scientific data sources with MOCHA and XRoaster},
	booktitle = {Thirteenth International Conference on Scientific and Statistical Database Management, 2001. SSDBM 2001. Proceedings},
	year = {2001},
	month = {2001///},
	pages = {263 - 266},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {MOCHA is a novel middleware system for integrating distributed data sources that we have developed at the University of Maryland. MOCHA is based on the idea that the code that implements user-defined types and functions should be automatically deployed to remote sites by the middleware system itself. To this end, we have developed an XML-based framework to specify metadata about data sites, data sets, and user-defined types and functions. XRoaster is a graphical tool that we have developed to help the user create all the XML metadata elements to be used in MOCHA},
	keywords = {client-server systems, data sets, data sites, Databases, Distributed computing, distributed databases, distributed scientific data source integration, Educational institutions, graphical tool, hypermedia markup languages, IP networks, java, Large-scale systems, Maintenance engineering, meta data, metadata, Middleware, middleware system, MOCHA, Query processing, remote sites, scientific information systems, user-defined types, visual programming, XML, XML metadata elements, XML-based framework, XRoaster},
	isbn = {0-7695-1218-6},
	doi = {10.1109/SSDM.2001.938560},
	author = {Rodriguez-Martinez,M. and Roussopoulos, Nick and McGann,J. M and Kelley,S. and Mokwa,J. and White,B. and Jala,J.}
}
@conference {16195,
	title = {Bringing treasures to the surface: iterative design for the Library of Congress National Digital Library Program},
	booktitle = {Proceedings of the SIGCHI conference on Human factors in computing systems},
	series = {CHI {\textquoteright}97},
	year = {1997},
	month = {1997///},
	pages = {518 - 525},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	keywords = {browse, design process, digital libraries, dynamic query, java, preview, search, web design},
	isbn = {0-89791-802-9},
	doi = {10.1145/258549.259009},
	url = {http://doi.acm.org/10.1145/258549.259009},
	author = {Plaisant, Catherine and Marchionini,Gary and Bruns,Tom and Komlodi,Anita and Campbell,Laura}
}
