Scott M. Pike

Department of Computer Science, Texas A&M University

Department of Computer Science, Texas A&M University
  • home »
  • publications »
  • View all publications
back

Links

  • Home
  • +  Research
    • Main research page
    • Research Project 1
    • Research Project 2
  • +  Teaching
    • Main teaching page
    • CPSC-668
    • CPSC-689
    • CPSC-410/611
  • +  Publications
    • All publications
    • Book Chapters
    • Conference Proceedings
    • Workshop Papers
  • Service
  • Resources
  • Personal
  • Current CV

Contact

  • pike[at]cse.tamu.edu
  • +1.979.776.2162 (tel)
  • +1.979.847.8578 (fax)
13

Publications

Publications listed by category and date of publication.

Please observe the copyright notices posted here governing the use of material from this page.

Click for papers indexed by

ACM, IEEE, DBLP, Springer, CiteSeer, and Google Scholar

Sort:

By Date: Newest publications first | Oldest publications first
By Category: Book Chapters | Conference Proceedings | Workshop Papers
By Publisher: ACM | ACTA | Cambridge | ETD | IEEE Xplore | None | Springer



ACM


  Encapsulating Concurrency as an Approach to Unification

  2004 [more]
ACMs Icon
  • Citation:
    Santosh Kumar, Bruce W. Weide, Paolo A.G. Sivilotti, Nigamanth Sridhar, Jason O. Hallstrom, and Scott M. Pike, "Encapsulating Concurrency as an Approach to Unification" in Proceedings of the Third Workshop on Specification and Verification of Component-Based Systems (SAVCBS), co-located with FSE 2004.
  • Abstract:
    We extend traditional techniques for sequential specifcation and verifcation to systems involving intrinsically concurrent activities. Our approach uses careful design of component specifcations to encapsulate inherent concurrency, and hence isolate clients from associated verifcation concerns. The approach has three parts: (i) relational specifcations to capture the interleaved effects of concurrent threads of execution, (ii) intermediate components to support a client's view of being the only active thread of computation, and (iii) a new specifcation clause to express requirements on a client's future behavior. We illustrate these ideas, and discuss their merits, in the context of a case study specifed using RESOLVE.
  • Publisher: ACM
  • Link to copy of this pubilcation on file with the publisher:

  • Download this publication:  
    KumarSAVCBS2004.ppt KumarSAVCBS2004.ppt
    Unification.pdf Unification.pdf
    Unification.ps Unification.ps




  Encapsulating Concurrency with Early-Reply

  2002 [more]
ACMs Icon
  • Citation:
    Scott M. Pike, "Encapsulating Concurrency with Early-Reply" in Companion Proceedings of the 17th ACM Conference on Object-Oriented Programming, Languages, Systems, and Applications OOPSLA 2002, pp. 18-19.
  • Abstract:
    Component methods often produce their final parameter values long before the method body is ready to terminate. To minimize client blocking, Early-Reply can be used to forward invocation results to the caller as soon as they are (safely) available. After executing Early-Reply, the method remainder and the client caller can proceed concurrently, modulo synchronization constraints. The prime motivation for Early-Reply, then, is to improve performance factors such as response time and resource utilization.Early-Reply received previous attention as a construct for explicit concurrent programming. It's value for sequential programming, however, has not been widely recognized. The present research supplies a formal treatment of Early-Reply as a basis for concurrent execution of sequential programs. In particular, we reformulate Early-Reply under local proof obligations that encapsulate concurrency as a (temporal) unit of information hiding. The upshot is that software developers can use Early-Reply to exploit the performance benefits of concurrent execution, without compromising the reasoning benefits of sequential programming.
  • Publisher: ACM
  • Link to copy of this pubilcation on file with the publisher:
    doi.acm.org/10.1145/985072.985082

  • Download this publication:  
    ECWER.pdf ECWER.pdf
    ECWER.ps ECWER.ps
    OOPSLA Final Program.pdf OOPSLA Final Program.pdf
    OOPSLA2002.bib OOPSLA2002.bib




  Checkmate: Cornering C++ Dynamic Memory Errors With Checked Pointers.

  2000 [more]
ACMs Icon
  • Citation:
    Scott M. Pike, Bruce W. Weide, and Joseph E. Hollingsworth, "Checkmate: Cornering C++ Dynamic Memory Errors With Checked Pointers." in Proceedings of SIGCSE 2000, pp. 352-356. © ACM Press 2000. Citations: [1] [2] [3] [4] [5] [6]
  • Abstract:
    Pointer errors are stumbling blocks for student and veteran programmers alike. Although languages such as Java use references to protect programmers from pointer pitfalls, the use of garbage collection dictates that languages like C++ will still be used for real-time mission-critical applications. Pointers will stay in the classroom as long as they're used in industry, so as educators, we must find better ways to teach them. This paper presents checked pointers, a simple wrapper for C++ pointers that prevents pointer arithmetic and other common sources of pointer errors, and detects all dereferencing and deallocation errors, including memory leaks. The syntax of checked pointers is highly faithful to raw C++ pointers, but provides run-time error detection and debugging information. After debugging, changing one #include is all that is required to substitute a non-checking implementation that is as fast as raw C++.
  • Publisher: ACM
  • Link to copy of this pubilcation on file with the publisher:
    portal.acm.org/citation.cfm?doid=330908.331884

  • Download this publication:  
    pointer-paper.pdf pointer-paper.pdf
    SIGCSE2000.bib SIGCSE2000.bib
    pointer-paper.html pointer-paper.html




Total Number of Publications: 13
publication admin

Last Modified: Mon Jul 21 11:14:57 CDT 2008
© Scott M. Pike (some rights reserved...)     My Erdös Number | Copyright | Site Map | Contact | About