NJPLS Seminar at the Stevens Institute of Technology, NJ on November 15, 2013

This instance of NJPLS will take place in the Howe Center, the tallest building in the campus, in the Bissinger room on the 4^th floor. Howe Center is number 19 on Stevens campus map.

Driving Directions to Stevens Institute of Technology.

Public Transportation.

Parking at Stevens.

Registration

Please Register by November 8 if you are planning to attend this event. Registration is free!

Program

This meeting of the NJPLS is dedicated to a harassment-free seminar experience for everyone. Our anti-harassment policy is available online.

Abstracts

• 10:00 – 10:30

Tempest: A Low-Level Language for a SAFE Machine

Jesse A. Tov, Harvard University

SAFE is a clean-slate effort to build a highly secure computer system, via simultaneous co-design of a new computer architecture, systems software, application software, and programming languages. The SAFE architecture has several peculiarities—pointer bounds checking, fine-grained programmable tags, linear pointers, closures, and no user-accessible stack—that make a conventional low-level language such as C unsuitable for writing the SAFE systems software. We have designed Tempest, a new language with several features intended to work well on SAFE, including flexible user-defined calling conventions, pointer arithmetic compatible with tags and bounds checking, robust support for inline assembly, a linear pointer type, and garbage collector integration. While Tempest’s type system prioritizes simplicity over soundness, the underlying machine provides memory safety. In this talk I introduce the design of Tempest, discuss the motivation for its novel features, and consider which aspects of Tempest’s design may be applicable beyond the SAFE project.

• 10:30 – 11:00

A Calculus of Located Entities

Adriana Compagnoni, Stevens Institute of Technology

(Joint work with Paola Giannini, Catherine Kim, Matthew Milideo and Vishakha Sharma)

In this paper, we define BioScape^L, a stochastic Pi-calculus in 3D-space with abstract locations. It builds on BioScape by associating with each entity a position in space, which is the barycentre of its associated shape. The position of an entity instance is programmable. This is similar to the origin of the affine transformation in Cardelli-Gardner’s 3π. The motivation for such an extension comes from the need to describe the assembly of configurations such as polymers, oligomers, and complexes in space, while keeping a high level description where diffusion and confinement remain part of the semantics of the calculus. In addition to this programmable deterministic translation, we can specify random translation and scaling. Random translation is not present in 3π, and scaling is more complex.

• 11:15 – 11:45

Teaching Compiler Construction using Higher Order Rewriting

Kristoffer H. Rose, IBM Thomas J. Watson Research Center

In this talk I discuss how a compiler generator based on higher-order rewriting is being used to teach a graduate level Compiler Construction class at NYU.

• 1:00 – 1:30

Putting PL research to work: A LogiQL Perspective

Jeff Vaughan, LogicBlox

"Enterprise software," which links information in a database with server-side applications and client-side user interfaces, is considered difficult to write and maintain.  There are technical causes for this: conventional query and update languages are unnecessarily complex, particular components only perform well for particular workloads, and full systems are built by gluing together many complicated pieces.

This talk will introduce the LogiQL programming language and LogicBlox database, which are designed to provide a simple programming model that addresses these problems.  LogiQL and LogicBlox are built on powerful ideas from programming language research including logic programming, purely functional data structures, clean semantic models, and incremental computation.  The talk will highlight how these ideas, and others from the academic languages community, play a important role in the implementation of the LogiQL language.

• 1:30 – 2:00

Computational and Mathematical Models of the JAK-STAT Signal Transduction Pathway

Vishakha Sharma, Stevens Institute of Technology

(Joint work with Adriana Compagnoni)

The JAK (Janus kinase)-STAT (Signal transducer and activator of transcription) signal transduction pathway is a cascade of downstream cellular events initiated from outside of

the cell through the cell surface to the DNA in the nucleus, causing transcription. The conventional modeling approach for signal transduction pathways involves solving ordinary differential equations (ODEs). We study here a computational alternative. We build two models of 46 reactions in the JAK-STAT pathway and compare the results. We implement a deterministic mathematical model using the ODEs solver COPASI, and we build a stochastic computational model using the Stochastic Pi Machine (SPiM).

Since dysregulation in the functionality of JAK-STAT pathway results in immune deficiency syndrome and cancers, like lymphomas, leukemia and breast cancer, we believe that models like this have the potential to contribute to cancer research.

• 2:00 – 2:30

How programming languages get popular and what we can do about it

Ariel Rabkin, Princeton University

Why do some languages succeed and others fail?  What happens when we stop thinking of adoption as a result and start considering it as a process or a resource? For the last few years, I've been using survey research to understand the language adoption process -- what makes programmers do what they do?

This talk describes the results of the research. I'll show what the most important factors are for motivating developers to use a language in a project. I'll show that this has consequences for the adoption process that are confirmed by mining software repositories. And I'll talk a bit about how developers conceptualize languages, and what this implies for designers and educators.

• 3:00 – 3:30

Using a High-Level Language to Program an FPGA to Play Blokus Duo

Stephen Fink, IBM Thomas. J. Watson Research Center

The vast majority of hardware designers employ design languages such as VHDL and Verilog, which provide a lower level of abstraction than languages used for software development. Using such tools, FPGA design requires much more time, effort, and expertise than programming equivalent functionality in software.

To make hardware design easier, many projects have investigated hardware synthesis from higher-level languages. To evaluate whether or not a high-level synthesis is viable, we must answer a key question: Using a high-level language, can a developer design hardware whose quality matches hardware designed with standard tools?

A design competition provides an attractive laboratory to test the question for a particular challenge. To this end, we have developed an entry for the 2013 ICFPT Blokus Duo Design Competition, built with the Liquid Metal system from IBM Research.

The Liquid Metal system provides a high-level language and toolchain targeting heterogeneous systems which mix CPUs, GPUs, and FPGAs. Liquid Metal is based on Lime, a Java-like language enhanced with constructs which express parallelism and isolation.

• 3:30 – 4:00

Demand-driven Incremental Computation of Object Queries

Jonathan Brandvein, Stony Brook University

(Joint work with Y. Annie Liu)

High-level query constructs over objects and sets greatly improve the clarity of programs. However, straightforward implementations of these queries are often much slower than equivalent manually written code. We provide a systematic method that generates incremental, demand-driven implementations by transforming programs to preserve invariants. The queries may involve objects and sets with arbitrary nesting and aliasing, as well as aggregation, and have no restrictions on the kinds of allowed updates. We also obtain asymptotic bounds on the worst-case running time and space usage. Previous approaches do not work for such expressive queries and kinds of updates, are more restrictive in the use of demand, or do not produce cost bounds.