POP
http://www.cs.cmu.edu/taxonomy/term/5761/all
enPrinciples 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.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.edu