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/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.eduPrinciples of Programming Seminar (POP)
http://www.cs.cmu.edu/calendar/mon-2014-09-08-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>Collection types have been proposed by Buneman and others (in the '90) as a way to capture database query languages in a typed setting. In 1998 Manes introduced the notion of collection monad on the category S of sets as a suitable semantics for collection types. The canonical example of collection monad is the finite powerset monad Pf.</p></div></div></div>Wed, 03 Sep 2014 23:21:02 +0000ccopetas178521 at http://www.cs.cmu.eduPrinciples of Programming Seminar (POP)
http://www.cs.cmu.edu/calendar/fri-2014-05-02-1330/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>Prior work in Functional Reactive Programming has sought to reconcile the seemingly imperative notion of interaction with the coding conventions and guarantees of functional programming, but this has often been at the cost of efficiency or expressiveness. We seek to combine the best of both worlds. To ensure predictable time and space performance, we use an imperative implementation. To regain a functional semantics, we must restrict the way in which streams can be used, but we wish to do so without restricting the syntax, thus hindering the expression of safe programs.</p></div></div></div>Sat, 26 Apr 2014 17:55:06 +0000ccopetas170751 at http://www.cs.cmu.eduPrinciples of Programming Seminar (POP)
http://www.cs.cmu.edu/calendar/principles-programming-seminar-pop-4
<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>We investigate possible extensions of arbitrary given Pure Type Systems with additional sorts and rules which preserve the normalization property. In particular we identify the following interesting extensions: the disjoint union P+Q of two PTSs P and Q, the PTS \forall P.Q which intuitively captures the "Q logic of P-terms'" and Ppoly which intuitively denotes the predicative polymorphism extension of P.</p>
<p>***</p></div></div></div>Fri, 21 Feb 2014 21:52:40 +0000ccopetas167391 at http://www.cs.cmu.eduPrinciples of Programming Seminar (POP)
http://www.cs.cmu.edu/calendar/principles-programming-seminar-pop-2
<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 will propose a simple category-theoretic foundation for functional reactive programming (FRP), which may also be useful in connection with incremental computation (IC). Both of these worlds involve objects that look like A-☐-B, as well as combinators that can be visualized as wiring diagrams. These boxes and combinators are often given meanings in terms of stream processors or state machines. I will give a categorical description of these ideas using symmetric monoidal categories.</p></div></div></div>Wed, 15 Jan 2014 23:22:33 +0000ccopetas164941 at http://www.cs.cmu.eduPrinciples of Programming (POP) Seminar
http://www.cs.cmu.edu/calendar/principles-programming-pop-seminar-5
<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>We explore practical inference rules for safety verification of continuous dynamical systems inspired by existing work in control. Sub-level sets of differentiable functions are very convenient for defining sets in continuous state space, however safety specifications often cannot be cast in this form without being conservative. It is far more natural to express system properties as Boolean formulas in which sub-level sets are atoms. A deductive verification system would benefit greatly from having the facility to both specify and reason effectively about invariance of such formulas.</p></div></div></div>Fri, 22 Nov 2013 20:39:24 +0000ccopetas163081 at http://www.cs.cmu.eduPrinciples of Programming Seminar (POP)
http://www.cs.cmu.edu/calendar/principles-programming-seminar-pop-1
<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">I will present a type-theory, for proving trace properties of programs that may execute adversary-supplied code. Our type system extends Hoare Type Theory (HTT) with post conditions that specify properties of the entire execution trace, not just the initial and final heaps. We also add invariant post conditions, which hold during the execution of a computation even if evaluation gets stuck or diverges.</p></div></div></div>Wed, 13 Nov 2013 20:51:43 +0000ccopetas162711 at http://www.cs.cmu.eduPrinciples of Programming Seminar (POP)
http://www.cs.cmu.edu/calendar/principles-programming-seminar-pop-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 class="MsoNormal">SMT is a branch of automatic reasoning concerned with determining the satisfiability of first-order formulas with respect to certain logical theories of interest. Its distinguishing feature is the use of specialized inference methods for each theory, and their incorporation into a general purpose deductive mechanism.</p></div></div></div>Mon, 04 Nov 2013 16:30:03 +0000ccopetas161811 at http://www.cs.cmu.edu