Summer School Talks

  • Compiling the Web

    Speaker: 
    Andreas Gal
    Location: 
    George Fox Lt5/6

    Over the last decade we have made great strides towards improving the execution performance of virtual-machines. Dynamic compilation is standard in Java VMs, enabling programs to execute with similar efficiency as legacy type-unsafe C code. However, much of the research effort in the Just-in-Time domain focused on statically typed languages, leaving an important and steadily growing field of programming languages behind: dynamically typed high level languages such as JavaScript, Python and Ruby.

  • Distributed Objects, Database Access, and Web Services

    Speaker: 
    William Cook
    Location: 
    George Fox Lt5/6

    <

    p>Most large-scale applications integrate remote services and/or transactional databases. Yet building software that efficiently invokes distributed service or accesses relational databases is still quite difficult. Existing approaches to these problems are based on the Remote Procedure Call (RPC), Object-Relational Mapping (ORM), or Web Services (WS). RPCs have been generalized to support distributed object systems. ORM tools generally support a form of query sublanguage for efficient object selection, but it is not well-integrated with the host language.

  • Performance Analysis of Idle Programs

    Speaker: 
    Matthew Arnold
    Location: 
    George Fox Lt5/6

    This talk presents an approach for performance analysis of modern enterprise-class server applications. In our experience, performance bottlenecks in these applications differ qualitatively from bottlenecks in smaller, stand-alone systems. Small applications and benchmarks often suffer from CPU-intensive hot spots. In contrast, enterprise-class multi-tier applications often suffer from problems that manifest not as hot spots, but as idle time indicating a lack of forward motion.

  • Practical Parallel and Concurrent Programming

    Speaker: 
    Thomas Ball
    Location: 
    George Fox Lt5/6

    On the multi-core computer many applications will make use of parallelism to achieve speedup and concurrency to achieve responsiveness. The .NET 4 Framework introduced new abstractions for parallelism and concurrency, but achieving good performance while maintaining correctness is still difficult. In this talk, I will describe courseware that introduces key concepts in parallelism and concurrency, with supporting code C#/F# code examples, as well as tests and new tools that support the twin goals of achieving high performing and correct code.

  • Programming language memory models: What do shared variables mean?

    Speaker: 
    Hans Boehm
    Location: 
    George Fox Lt5/6

    For at least three decades we have had programming languages that support threads communicating via shared variables. Unfortunately, a large amount of confusion has surrounded the semantics of those shared variables and associated synchronization mechanisms. The confusion has become visible as widely differing assumptions about the basics of thread programming, software bugs, and sometimes conflicting assumptions made by different research papers.

  • Proving That Programs Eventually Do Something Good

    Speaker: 
    Byron Cook
    Location: 
    George Fox Lt5/6

    Software failures can be sorted into two groups: those that cause the software to do something wrong (e.g. crashing), and those that result in the software not doing something useful (e.g. hanging). In recent years automatic tools have been developed which use mathematical proof techniques to certify that software cannot crash. But, based on Alan Turing's proof of the halting problem's undecidablity, many have considered the dream of automatically proving the absence of hangs to be impossible.

  • The Rise of Dynamic Languages

    Speaker: 
    Jan Vitek
    Location: 
    George Fox Lt5/6

    Dynamic programming languages—like Python, R, and JavaScript—are the new paradigm for applications ranging from web programming to scientific computing, particularly for data-intensive work, due to their ease of use, instant feedback, and large set of available libraries.  In this talk, I’ll describe the what, where, why, and how of this trend – what dynamic languages are and how they’re different, where they are being used, why the shift is happening, how it improves productivity, the perceived vs. real differences in performance, and much more.

  • Turning a Tower of Babel into a Beautiful Racket

    Speaker: 
    Matthew Flatt
    Location: 
    George Fox Lt5/6

    No matter how language designers try to create elegant, consistent, all-powerful programming languages, the pressures of real-world programming tasks consistently drive the demand for new programming constructs and domain-specific languages. Extensible languages such as Racket address this problem by allowing programmers to create new constructs and DSLs as needed. Racket inherits its basic approach to extensibility from Lisp and Scheme, but Racket's unique features enable an even greater degree of language extension and composition.