POP
http://www.cs.cmu.edu/taxonomy/term/5761/all
enPrinciples 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.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/tue-2015-12-15-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>A classic problem in parallel computing is determining whether to execute a thread in parallel or sequentially. If small threads are executed in parallel, the overheads due to thread creation can overwhelm the benefits of parallelism, resulting in suboptimal efficiency and performance. If large threads are executed sequentially, processors may spin idle, resulting again in suboptimal efficiency and performance.</p></div></div></div>Fri, 11 Dec 2015 00:06:17 +0000ccopetas613351 at http://www.cs.cmu.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/thu-2015-12-03-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 a recent work on new semantics for Hoare Logic. Instead of using Hoare Logic to prove functional correctness, I recycle it to prove invariants true during the whole execution of a program. The pre-conditions are put forward and characterize the initial states allowing the program to execute safely (i.e. not break the invariant). The post-conditions now simply serve compositionality and allow modular reasoning. I will show on a trivial language how we define the semantic validity of Hoare triples in such a setting and how soundness and completeness of the logic are proved.</p></div></div></div>Tue, 01 Dec 2015 21:48:20 +0000ccopetas613253 at http://www.cs.cmu.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/mon-2015-10-26-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>According to conventional wisdom, a self-interpreter for a strongly normalizing lambda-calculus is impossible.We call this the normalization barrier. The normalization barrier stems from a theorem in computability theory that says that a total universal function for the total computable functions is impossible. I will show how to break through the normalization barrier and define a self-interpreter for a widely used strongly normalizing lambda-calculus.</p></div></div></div>Wed, 21 Oct 2015 22:14:45 +0000ccopetas612221 at http://www.cs.cmu.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/thu-2015-10-22-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>Many authors have suggested ways of adding random elements and probability assessments to versions of Church's Lambda-Calculus. Recently the speaker realized that the so-called Graph Model (based on using enumeration operators acting on the powerset of the integers) could easily be expanded to include random variables taking values in the powerset. The talk will also report on how a continuation-passing semantics can be used for modeling a branching combinator using random coin tossing. The idea can also be employed for introducing many other random combinators.</p>
<p>—</p></div></div></div>Wed, 14 Oct 2015 17:21:27 +0000ccopetas584621 at http://www.cs.cmu.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/thu-2015-10-08-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 class="MsoNormal"><span>An adequate type-theoretic semantics for natural language expressions must account for the presuppositions that are expressed by determiners and pronouns. To this end, we extend Type Theory with a choice operator called "require", which functions as a non-deterministic oracle to retrieve the synthesis of a previously-effected verification of a proposition. Then, we give an intuitionistic semantics to this operator by appealing to Brouwer's theory of the Creating Subject, and eliminate non-determinism via spreads and choice sequences.</span></p></div></div></div>Sat, 26 Sep 2015 18:01:56 +0000ccopetas583821 at http://www.cs.cmu.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/wed-2015-07-01-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>Functional programming languages like ML descend conceptually from minimal lambda calculi, but to be pragmatic, expose a concrete syntax and type structure to programmers of a more elaborate design. Language designers have many viable choices at this level, as evidenced by the diversity of dialects that continue to proliferate around these languages. But language dialects cannot be modularly combined, limiting the choices available to programmers.</p></div></div></div>Wed, 01 Jul 2015 15:06:27 +0000ccopetas581061 at http://www.cs.cmu.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/mon-2015-05-11-1430/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>A computation is incremental if repeating it with a changed input is faster than from-scratch recomputation. Many software systems use incremental computation (IC) as a fundamental aspect of their design. Everyday examples include spreadsheets (incremental formula evaluation), development environments (incremental type checking, static analysis, translation, optimization) and database interaction (incremental view maintenance).</p></div></div></div>Tue, 05 May 2015 21:06:02 +0000ccopetas195201 at http://www.cs.cmu.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/fri-2015-05-01-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 class="MsoNormal"><span>Recent years have seen growing interest in high-level languages for programming networks. But the design of these languages has been largely ad hoc, driven more by the needs of applications and the capabilities of network devices than by foundational principles. The lack of a semantic foundation has left language designers with little guidance in determining how to incorporate new features, and programmers without a means to reason precisely about their code. <br /></span></p></div></div></div>Fri, 01 May 2015 14:34:57 +0000ccopetas194971 at http://www.cs.cmu.edu