POP
http://www.cs.cmu.edu/taxonomy/term/5761/all
enPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/mon-2016-10-17-1530/principles-programming-seminar
<div class="field field-name-body field-type-text-with-summary field-label-hidden"><div class="field-items"><div class="field-item even" property="content:encoded"><p>Probabilistic couplings are a standard mathematical abstraction for reasoning about two distributions. In formal verification, they are often called probabilistic liftings. While these two concepts are quite related, the connection has been little explored. In fact, probabilistic couplings and liftings are a powerful, compositional tool for reasoning about probabilistic programs. I will give a brief survey of different uses of probabilistic liftings, and then show how to use these ideas in the relational program logic pRHL.</p></div></div></div>Mon, 17 Oct 2016 17:38:12 +0000ccopetas624379 at http://www.cs.cmu.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/wed-2016-10-19-1530/principles-programming-seminar
<div class="field field-name-body field-type-text-with-summary field-label-hidden"><div class="field-items"><div class="field-item even" property="content:encoded"><p><span>It's tempting to think that machine instructions are atomic updates to<span> </span>a global mutable state, of register and memory values. In the<span> </span>sequential world that's a good model, but concurrent contexts expose a<span> </span>slew of more interesting behaviour. We set out to understand real<span> </span>multiprocessor semantics in 2007, to give a basis for software verification. We're still not done, but we now have credible<span> </span>operational models for much of what goes on. I'll talk about some key<span> </span>points of this, including</span></p></div></div></div>Fri, 14 Oct 2016 20:45:05 +0000ccopetas624361 at http://www.cs.cmu.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/wed-2016-10-26-1500/principles-programming-seminar
<div class="field field-name-body field-type-text-with-summary field-label-hidden"><div class="field-items"><div class="field-item even" property="content:encoded"><p>Rust is a new systems-programming language that is becoming increasingly popular. It aims to combine C++'s focus on zero-cost abstractions with numerous ideas that emerged first in academia, most notably affine and region types ("ownership and borrowing") and Haskell's type classes ("traits"). One of the key goals for Rust is that it does not require a garbage collector.</p></div></div></div>Mon, 10 Oct 2016 20:21:50 +0000ccopetas624325 at http://www.cs.cmu.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/thu-2016-10-13-1530/principles-programming-seminar
<div class="field field-name-body field-type-text-with-summary field-label-hidden"><div class="field-items"><div class="field-item even" property="content:encoded"><p>In this talk I will present Hazelnut, a structure editor based on a small bidirectionally typed lambda calculus extended with holes and an internal notion of a cursor. Existing structure editors only guarantee a weak syntactic well-formedness. Hazelnut goes one step further: the possible edit actions maintain static well-definedness. Naively, this prohibition on ill-typed edit states would force the programmer to construct terms in a rigid outside-in manner.</p></div></div></div>Thu, 06 Oct 2016 22:06:49 +0000ccopetas624297 at http://www.cs.cmu.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/fri-2016-09-30-1500/principles-programming-seminar
<div class="field field-name-body field-type-text-with-summary field-label-hidden"><div class="field-items"><div class="field-item even" property="content:encoded"><p>Software has become a central and integral part of many systems and products of the information era. In embedded and cyber-physical systems, software is not an isolated component but instead an integrated part of larger, e.g. technical or mechanical systems. During the last decade, there has been an exponential growth in the size of embedded software, resulting in an increasing need for software engineering methods addressing the special needs of the embedded and cyber-physical domain.</p></div></div></div>Wed, 21 Sep 2016 20:59:30 +0000ccopetas624023 at http://www.cs.cmu.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/thu-2016-09-15-1630/principles-programming-seminar-0
<div class="field field-name-body field-type-text-with-summary field-label-hidden"><div class="field-items"><div class="field-item even" property="content:encoded"><p>Julia is a relatively new language gaining popularity in technical computing and data analysis fields. It began as an attempt to understand the appeal of languages like Matlab, R, and Python/NumPy at a fundamental level, and to ask how they can be improved. We arrived at a design based on subtyping and multiple dispatch that provides a good tradeoff between performance and productivity for many users. This talk will discuss some of Julia's more novel features, particularly its subtyping and method system, and some possible future directions.</p>
<p>—</p></div></div></div>Mon, 12 Sep 2016 16:56:15 +0000ccopetas623887 at http://www.cs.cmu.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/thu-2016-09-29-1530/principles-programming-seminar
<div class="field field-name-body field-type-text-with-summary field-label-hidden"><div class="field-items"><div class="field-item even" property="content:encoded"><p>Trading in financial markets is a data-driven affair, and as such, it requires applications that can efficiently filter, transform and present data to users in real time.</p>
<p>But there's a difficult problem at the heart of building such applications: finding a way of expressing the necessary transformations of the data in a way that is simultaneously easy to understand and efficient to execute over large streams of data.</p></div></div></div>Mon, 12 Sep 2016 16:48:01 +0000ccopetas623885 at http://www.cs.cmu.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/wed-2016-09-21-1600/principles-programming-seminar
<div class="field field-name-body field-type-text-with-summary field-label-hidden"><div class="field-items"><div class="field-item even" property="content:encoded"><p>AUTO2 is a new heuristic theorem prover written for the proof assistant Isabelle. It uses a robust search mechanism that bears some similarity to those used in SMT solvers. On the other hand, it retains several advantages of the tactics framework in Isabelle, such as allowing custom procedures and working with higher-order logic. In this talk, I will discuss the ideas behind auto2 and show some examples of its use in various parts of mathematics and computer science. In the end I will also discuss the more recent application to automation in separation logic.</p>
<p>—</p></div></div></div>Tue, 06 Sep 2016 22:00:26 +0000ccopetas623605 at http://www.cs.cmu.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/thu-2016-06-16-1530/principles-programming-seminar
<div class="field field-name-body field-type-text-with-summary field-label-hidden"><div class="field-items"><div class="field-item even" property="content:encoded"><p>The λΠ-calculus modulo theory, implemented in the Dedukti system, is a logical framework where many theories can be expressed: constructive and classical predicate logic, Simple type theory, programming languages, Pure type systems, the Calculus of inductive constructions with universes... This allows to use it to check large libraries of proofs coming from various proofsystems: Zenon, iProver, FoCaLiZe, HOL-Light, and Matita.</p>
<p>—</p></div></div></div>Fri, 03 Jun 2016 15:51:34 +0000ccopetas615365 at http://www.cs.cmu.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/thu-2016-05-05-1000/principles-programming-seminar
<div class="field field-name-body field-type-text-with-summary field-label-hidden"><div class="field-items"><div class="field-item even" property="content:encoded"><p>In recent years, Boolean Satisfiability (SAT) solvers have been successfully used in many practical applications. Given a propositional formula, the SAT problem consists in deciding if the formula is satisfiable or unsatisfiable. For unsatisfiable formulas, we are often interested in knowing what is the maximum number of clauses that can be simultaneously satisfied. Such problem is known as the Maximum Satisfiability (MaxSAT) problem, the optimization counterpart to SAT as a decision problem.</p></div></div></div>Wed, 04 May 2016 21:07:41 +0000ccopetas614781 at http://www.cs.cmu.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/thu-2016-04-21-1530/principles-programming-seminar
<div class="field field-name-body field-type-text-with-summary field-label-hidden"><div class="field-items"><div class="field-item even" property="content:encoded"><p>Modern GPUs provide supercomputer-level performance at commodity prices, but they are notoriously hard to program. To address this problem, we have been exploring the use of Nested Data Parallelism (NDP), and specifically Guy Blelloch's first-order functional language NESL, as a way to raise the level of abstraction for programming GPUs. Preliminary results suggest that NDP can be effectively mapped onto GPUs, but there is significant work required to make this mapping competitive with handwritten GPU code.</p></div></div></div>Mon, 11 Apr 2016 18:50:57 +0000ccopetas614573 at http://www.cs.cmu.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/fri-2016-04-29-1400/principles-programming-seminar
<div class="field field-name-body field-type-text-with-summary field-label-hidden"><div class="field-items"><div class="field-item even" property="content:encoded"><p>The precise semantics of floating-point arithmetic programs depends on the execution platform, including the compiler and the target hardware. Platform dependencies are particularly pronounced for arithmetic-intensive scientific numeric programs and infringe on the highly desirable goal of software portability (which is in fact promised by heterogeneous computing frameworks like OpenCL): the same program run on the same inputs on different platforms can produce different results.</p></div></div></div>Fri, 08 Apr 2016 19:23:14 +0000ccopetas614543 at http://www.cs.cmu.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/thu-2016-04-07-1500/principles-programming-seminar
<div class="field field-name-body field-type-text-with-summary field-label-hidden"><div class="field-items"><div class="field-item even" property="content:encoded"><p>The key to scalable program synthesis is modular verification: the better a specification for a program can be broken up into independent specifications for its components, the fewer combinations of components the synthesizer has to consider, leading to a combinatorial reduction in the size of the search space. This talk will present Synquid: a synthesizer that takes advantage of the modularity offered by type-based verification techniques to efficiently generate recursive functional programs that provably satisfy a given specification in the form of a refinement type.</p></div></div></div>Mon, 28 Mar 2016 18:27:59 +0000ccopetas614417 at http://www.cs.cmu.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/thu-2016-01-28-1400/principles-programming-seminar
<div class="field field-name-body field-type-text-with-summary field-label-hidden"><div class="field-items"><div class="field-item even" property="content:encoded"><p>I present an extensive formalization of Markov chains (MCs) and Markov decision processes (MDPs), with discrete time and (possibly infinite) discrete state-spaces. The formalization takes a coalgebraic view on the transition systems representing MCs and constructs their trace spaces. On these trace spaces properties like fairness, reachability, and stationary distributions are formalized.</p></div></div></div>Thu, 14 Jan 2016 20:15:19 +0000ccopetas613641 at http://www.cs.cmu.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/mon-2016-01-25-1400/principles-programming-seminar
<div class="field field-name-body field-type-text-with-summary field-label-hidden"><div class="field-items"><div class="field-item even" property="content:encoded"><p>The 2011 C and C++ standards introduced a weak memory model, whose aim was to enable many compiler optimisations as possible, while providing some useful guarantees to the programmers. Sadly, however, as I will demonstrate, the formal model falls short of its intensions: it not only does not provide its expected DRF guarantee, but it also does not permit many common source-to-source program transformations (such as expression linearisation and “roach motel” reorderings) that modern compilers perform and that are deemed to be correct.</p></div></div></div>Tue, 12 Jan 2016 20:21:26 +0000ccopetas613619 at http://www.cs.cmu.edu