Pages using the term: <i>POP</i>
http://www.cs.cmu.edu/taxonomy/term/5761/all
enPrinciples 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.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/wed-2015-02-25-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>Ordinary Differential Equations (ODEs) are ubiquitous inphysical applications of mathematics. The Picard-Lindelöf theorem is the first fundamental theorem in the theory of ODEs. It allows one to solve differential equations numerically. We provide a constructive development of the Picard-Lindelöf theorem which includes a program together with sufficient conditions for its correctness. The proof/program is written in Coq and uses the implementation of efficient real numbers from the CoRN library and the MathClasses library.</p></div></div></div>Wed, 25 Feb 2015 17:28:55 +0000ccopetas191342 at http://www.cs.cmu.eduPrinciples of Programming Seminar
http://www.cs.cmu.edu/calendar/mon-2015-02-16-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>Modeling languages for hybrid systems are cornerstones of embedded systems development in which software interacts with a physical environment. Sequential code generation from such languages is important for simulation efficiency and for producing code for embedded targets. Despite being routinely used in industrial compilers, code generation is rarely, if ever, described in full detail, much less formalized. Yet formalization is an essential step in building trustable compilers for critical embedded software development.</p></div></div></div>Tue, 10 Feb 2015 22:20:17 +0000ccopetas190422 at http://www.cs.cmu.eduPrinciples of Programming Seminar (POP)
http://www.cs.cmu.edu/calendar/tue-2014-11-25-1500/principles-programming-seminar-pop
<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>Code review is a fundamental part of developing high quality software. Pretty much every software organization that cares about good code has some kind of code review system in place.</p>
<p>But automating code review, particularly for a large and complex codebase that has many active contributors, is surprisingly challenging. This is especially so for a correctness-critical codebase where it's important that review be done completely, even in awkward corner-cases.</p></div></div></div>Thu, 20 Nov 2014 20:52:56 +0000ccopetas184512 at http://www.cs.cmu.eduPrinciples of Programming Seminar (POP)
http://www.cs.cmu.edu/calendar/mon-2014-09-22-1215/principles-programming-seminar-pop
<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>Lumsdaine and Shulman's concept of Higher Inductive Types (HITs) is one of the major new features of Homotopy Type Theory (HoTT). HITs generalise ordinary inductive types, as well as quotient types, but also geometrical objects such as intervals, pheres or tori can be represented using HITs, leading the way to synthetic homotopy theory. However, while we know of particular examples of HITs, we do not yet have a general schema for well-behaved such definitions.</p></div></div></div>Thu, 18 Sep 2014 16:25:30 +0000ccopetas180432 at http://www.cs.cmu.eduPrinciples of Programming Seminar (POP)
http://www.cs.cmu.edu/calendar/fri-2014-09-19-1500/principles-programming-seminar-pop
<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>Equilogical spaces were introduced by Dana Scott in his seminal paper on Data Types as Lattices as a "good category of spaces for computation". We shall review the presentation of the category of equilogical spaces and present two applications to logic. The first is that it subsumes a model for Martin-Löf Type Theory where to discuss the univalent axiom with respect to topological spaces. The second is to give a synthetic presentation of the category of frames which suggest that frames are algebras for geometric logic.</p></div></div></div>Thu, 18 Sep 2014 16:16:56 +0000ccopetas180422 at http://www.cs.cmu.edu