-
Notifications
You must be signed in to change notification settings - Fork 8
Papers and Presentations
Date: 2016-08-08, 2015-09-23
Title: Better Code: Data Structures
Abstract: The standard library containers are often both misused and underused. Instead of creating new containers, applications are often structured with incidental data structures composed of objects referencing other object. This talk looks at some of the ways the standard containers can be better utilized and how creating (or using non-standard library) containers can greatly simplify code. The goal is no incidental data structures.
Notes: This is the version of the talk presented at Bloomberg.
Notes: This is the version of the talk presented at CppCon 2015.
Date: 2016-08-08, 2015-04-21, 2015-02-27
Title: Better Code: Concurrency
Abstract: Despite all of the recent interest, concurrency in standard C++ is still barely in its infancy. This talk uses the primitives supplied by C++14 to build a simple, reference, implementation of a task system. The goal is to learn to write software that doesn’t wait.
Notes: This is the version of the talk presented at Bloomberg.
Notes: This is the version of the talk presented at the Bay Area C++ User Group Meeting.
Notes: This is the version of the talk I presented at the C++ Russia Conference, 2015 (1). I presented an earlier draft at the ACCU, Silicon Valley Chapter (2).
Date: 2016-08-06
Title: An interview with Sean Parent
Abstract: Jens Weller from Meeting C++ interviewed me following my C++Now keynote.
Data: 2016-07-18
Title: One Way to Select Many
Authors: Jaakko Järvi, Sean Parent
Abstract: Selecting items from a collection is one of the most common tasks users perform with graphical user interfaces. Practically every application supports this task with a selection feature different from that of any other application. Defects are common, especially in manipulating selections of non-adjacent elements, and flexible selection features are often missing when they would clearly be useful. As a consequence, user effort is wasted. The loss of productivity is experienced in small doses, but all computer users are impacted. The undesirable state of support for multi-element selection prevails because the same selection features are redesigned and reimplemented repeatedly. This article seeks to establish common abstractions for multi-selection. It gives generic but precise meanings to selection operations and makes multi-selection reusable; a JavaScript implementation is described. Application vendors benefit because of reduced development effort. Users benefit because correct and consistent multi-selection becomes available in more contexts.
Notes: Paper to be presented at ECOOP 2016
Date: 2016-05-16
Title: Better Code
Abstract: The process of improving an existing body of code can be very challenging. In this talk I'll offer a concise definition of "good code", inherent tradeoffs in any system, and techniques for approaching a large code base.
Notes: Talk presented as keynote at C++Now 2016 and ICPC 2016.
Date: 2015-10-26
Title: Generating Reactive Programs for Graphical User Interfaces from Multi-way Dataflow Constraint Systems
Authors: Gabriel Foust, Jaakko Järvi, Sean Parent
Abstract: For a GUI to remain responsive, it must be able to schedule lengthy tasks to be executed asynchronously. In the traditional approach to GUI implementation–writing functions to handle individual user events–asynchronous programming easily leads to defects. Ensuring that all data dependencies are respected is difficult when new events arrive while prior events are still being handled. Reactive programming techniques, gaining popularity in GUI programming, help since they make data dependencies explicit and enforce them automatically as variables’ values change. However, data dependencies in GUIs usually change along with its state. Reactive programming must therefore describe a GUI as a collection of many reactive programs, whose interaction the programmer must explicitly coordinate. This paper presents a declarative approach for GUI programming in which the programmer is relieved from coordinating asynchronous computations. The approach is based on our prior work on “property models”, where GUI state is maintained by a dataflow constraint system. A property model responds to user events by atomically constructing new data dependencies and scheduling asynchronous computations to enforce those dependencies. In essence, a property model dynamically generates a reactive program, adding to it as new events occur. The approach gives the following guarantee: the same sequence of events produces the same result, regardless of the duration of processing the events.
Notes: Paper presented at GPCE 2015.
Date: 2014-05-14
Title: Goal: Implement Complete & Efficient Types
Abstract: The C++ Seasoning talk presented at GoingNative 2013 centered on 3 goals for better code. This talk provides foundational material on types, references, and basis operations. We'll look at how the definition of type, and physical nature of the machine, leads to the conclusion that all types are regular and why implementing complete types is a worthy goal.
Date: 2013-09-11
Title: C++ Seasoning
Abstract: A look at many of the new features in C++ and a couple of old features you may not have known about. With the goal of correctness in mind, we'll see how to utilize these features to create simple, clear, and beautiful code. Just a little pinch can really spice things up.
Notes: This is the ACCU, Silicon Valley Chapter version of the talk originally given at GoingNative 2013. The talk is also known as "3 Goals for Better Code." This version contains an expanded ending to the polymorphism code, starting on page 179 of the PDF, and some optional slides that did not make that talk. The extended version of the talk was also given at A9.
Date: 2013-09-11
Title: Inheritance Is The Base Class of Evil
Abstract: Implementing non-intrusive runtime polymorphic objects with value-semantics, and multiple-undo in 20 minutes.
Notes: This is an abbreviated version of the Value Semantics and Concept-based Polymorphism talk linked to below given at GoingNative 2013.
Date: 2013-09-06 Updated: 2013-09-24
Title: Value Semantics and Concept-based Polymorphism
Abstract: This talk explains why (and how) to implement polymorphism without inheritance in C++. The talk contains many C++ tips and techniques, including many new features from C++11. During the course of that talk a key feature from Photoshop will be demonstrated and implemented.
Date: 2013-03-05
Title: Language Delay
Abstract: A look at how programming languages are failing to keep up with a rapidly changing hardware and business landscape. Not long ago it was clear to everyone that because of the rate at which clock speeds were doubling the industry should be optimizing for programmer productivity and let the hardware solve the performance issues. More recently both the dynamics of hardware and the business landscape have thrown these assumptions out the window and left a large vacuum in the programming language landscape. This talk takes a looks at how much things have changed and how a reset in our approach is needed.
Date: 2012-05-17
Title: Now What? A vignette in 3 parts
Abstract: Part 1: Beauty C++ has seen a resurgence in usage as efficiency has come to dominate costs. Yet many still hold their nose as they move to C++. It can be a frightening transition for a programmer coming from Java, JavaScript, or Python. As a community we need to leverage the tools provided by C++11 to write beautiful, efficient, code.
Part 2: Truth On modern hardware, straight C++ code gives you access to just 0.25% of the available performance on the machine. With C++11 we unlock only a little more with thread support. One of the largest challenges for the language and libraries going forward will be how to get at the other 99.75% of the machine.
Part 3: Goodness A plethora of networked devices is changing the software landscape. The infrastructure of the internet is fading into the background and increasingly customers are expecting all of their information, available on all their devices, instantly. What impact do such systems have on how we architect and write software? What is the role C++ will play in this new world.
Some of my older papers and presentation can be found here.