| title | permalink | tagline | layout | comments |
|---|---|---|---|---|
Papers and Presentations |
/papers-and-presentations/ |
Too many projects, too little time |
page |
true |
{:.no_toc}
- [place holder] {:toc}
Date: 2024-05-16, 2024-09-12
Local reasoning is the ability to look at a defined unit of code, a function, or a class, understand it, and verify its correctness without understanding all the contexts within which it is used. This talk covers local reasoning principles and explores conventions and rules to support local reasoning and develop better interfaces and code.
Note: This talk was presented at NDC TechTown, 2024-09-12.
Note: This talk was presented at the Northwest C++ Users' Group.
Date: 2024-03-07
Starting from separating function execution context from a function result, this talk looks at the ensuing problem space and pursues an alternative path to sender/receivers, emphasizing simplicity and low latency in a dynamic environment.
Note: This talk was presented at the NYC++ Meetup.
Date: 2023-10-06
Coauthored and presented with Dave Abrahams.
Are you confident that the code you write and your changes are correct? What does “correct” even mean? How do we know the code we write today won’t become a long-term liability? These persistent questions can be enough to suck all the fun out of programming, but it doesn’t have to be that way. In this talk, we’ll look at the connective tissue of good code and show how to keep it strong and supple. There is no need to wait for language features to start using contracts. We’ll suggest replacing code reviews with something better and charting the path to a more hopeful future of software.
Note: This talk was presented at the CppCon 2023 conference, 2023-10-06.
Date: 2023-09-28
Algorithm composition is the process of combining existing algorithms to create new ones that solve complex problems. This talk looks at different forms of composition with different trade-offs. The talk will inspire you to think of algorithms as reusable building blocks that can be combined in novel ways.
Note: This talk was presented internally at Adobe and is available on the Adobe Developer site.
Date: 2023-06-08, 2023-05-25
A function is a fundamental building block in software development and a key tool for designing efficient and maintainable systems. This talk looks at the characteristics of a “good” function and provides practical guidance on when and how to refactor and utilize existing libraries to develop Better Code.
Note: This talk was presented internally at Adobe and is available on the Adobe Developer site.
Initial draft version:
Date: 2023-06-28, 2023-05-08
Safety is a hot topic. What do we mean by safety? How does it relate to correctness? What about security? This talk proposes a taxonomy of general computer science terminology with specifics about how it applies to C++ and how this better understanding can be used to write Better Code.
Note: This is a revised version of the talk presented at the CppOnSea 2023 conference, 2023-06-28.
Note: This talk was presented at the C++Now 2023 conference, 2023-05-08.
Date: 2023-06-08, 2023-05-25
Abstract: A function is a fundamental building block in software development and a key tool for designing efficient and maintainable systems. This talk looks at the characteristics of a “good” function and provides practical guidance on when and how to refactor and utilize existing libraries to develop Better Code.
Note: This is a shorter version of the What's Your Function? talk below, and was presented internally at Adobe - revised.
Note: This is a shorter version of the What's Your Function? talk below, and was presented internally at Adobe.
Date: 2023-02-15
Abstract: A function is a fundamental building block in software development and a vital tool for designing efficient and maintainable systems. This talk looks at the characteristics of a “good” function and provides practical guidance on when and how to refactor and utilize existing libraries to develop Better Code.
Note: This talk was presented at the Northwest C++ User’s Group. The slides linked from here are generated from a Jupyter notebook and are under development.
Date: 2022-08-31, 2022-05-05
Abstract: When discussing exceptions, there is a focus on when to throw an exception and how to propagate it. However, little attention is given to how to recover from an exception. By looking at error handling and what it means to recover from an error, we can understand the requirements to handle exceptions correctly. We'll see that shifting perspective helps develop usable operations and types.
Note: Talk presented internally at Adobe. This version was edited for time. 2022-08-31
Note: Talk presented at C++Now 2022. The slides here contain minor corrections, 2022-05-05
Date: 2022-08-29
Abstract: Personal computers and devices are unbelievably fast but often struggle to keep up with mundane tasks. Why hasn't software managed to scale in performance with hardware? This talk looks at some of the reasons, the characteristics of fast systems, the limits of human perception, and the need to rethink how software is authored to build efficient systems.
Note: Talk presented at Skills Matter Performance Summit 2022.
Date: 2022-07-20
Abstract: Ten years ago, soon after the release of C++11, I presented a talk at C++Now titled C++ Now What? That talk looked at where C++ should go next. In the last decade, what progress has been made? This talk examines why C++ remains successful, where we still have gaps, and what gaps have widened. Will the next decade bring more of the same or something fundamentally different?
Additional commentary about this talk is available [here]({% post_url 2022-07-26-the-tragedy-of-c %}).
Note: Talk presents at CppNorth 2022, 2022-07-20
Date: 2021-11-14, 2021-10-24, 2021-06-19
Abstract: We often take it for granted that calling one of the Standard algorithms will do something meaningful. For example, when invoking position = find(first, last, value) we expect that if an element equal to value is contained in the range [first, last) then position will point to the first such element; otherwise, position will equal last. But how do we know find will perform this operation? This talk explores requirements, guarantees, and domains, and we'll discover that maybe find doesn't.
Note: Talk presented at HiPar under the alternative title, Reasoning About Software Correctness, 2021-11-24
Note: Talk presented at CppCon, 2021-10-24
Note: Talk presented at Italian C++ 2021, 2021-06-19
Note: My pointer/cursor was not visible in the video feed, making some of the code discussion harder to follow.
Date: 2021-10-19
Abstract: Not too many years ago, the machine architecture supported by consumer devices looked to be converging on a largely uniform model, the Intel x86 instruction set & OpenCL/GL GPU computation. But now, hardware architecture is increasingly fragmented and complex, while at the same time, the marketplace is demanding higher performance and interactivity across a more extensive range of devices. This talk looks at how we got here, the challenges of supporting these architectures from software applications, and an opening to discuss how software languages will play a role in making sense of the chaos.
Note: Talk presented at Rebase 2021 as a discussion with Mario Wolczko, 2021-10-19
Date: 2021-03-13, 2019-10-31, 2019-09-19
Abstract: Computer scientists are bad at relationships. Nearly every program crash is rooted in a mismanaged relationship, yet we spend most of our time discussing types and functions and not the relationships connecting them. This talk looks at common ways data and code are connected in an application, how those relationships are typically represented, and the problems caused by the use and misuse of these paradigms. Then, we'll look at ways to model these relationships in C++ and use them to build correct applications.
Note: Talk presented at ACCU 2021, 2021-03-13
Note: Talk presented at C++ Russia 2019, 2019-10-31
Note: Talk presented at CppCon 2019, 2019-09-19.
Erratum: In the video, the slide for erasing an element from the registry contains a bug. It fails to check if the element has already been erased. It is fixed in the posted slides.
Date: 2019-10-31
Abstract: Ruminations on composability, why functional composition is inherently limited, and why we need a better theory of composition.
Note: Lightning talk presented at C++ Russia, 2019-10-31
Date: 2019-03-20
Abstract: A "behind the scenes" look at the challenges to bring one of Adobe's premier products to mobile devices and the role that C++ developments have played in overcoming them.
Note: Talk presented at the Northwest C++ Users' Group, 2019-03-20.
Date: 2018-11-08, 2018-10-18
Abstract: The term "Generic Programming" was coined by Alex Stepanov and David Musser in 1988. It has become one of the most influential ideas to shape programming and has had a profound impact on the evolution of C++. Yet, the core concepts of generic programming are still often misunderstood and misrepresented. Thirty years in, this talk will look a little at how generic programming came to be and why it is not simply "another paradigm" for software development.
Erratum: The slide Jon Bentley's Solution (Translated to C++) contains an error. The line, int u = n; should read int u = n - 1;. The slides have been updated with the fix. Thanks to Alex Muscar.
Addition: When preparing this talk, I was unable to find a picture of Meng and Alex from the Al Stevens interview in Dr. Dobb's Journal, March 1995. Alex was kind enough to give me a copy of the original publication.
Note: Talk presented at code::dive 2018, 2018-11-08.
Note: Talk presented at pacific++ 2018, 2018-10-18.
Date: 2018-09-28, 2017-11-09, 2017-11-06
Abstract: This talk explains the relationship between good code and a good human interface (graphical or otherwise). Human interface semantics are tightly coupled with code semantics, and improving how we reason about code can have a direct and positive impact on the human interface behavior of the system. As part of my "Better Code" series of talks, the goal is "Don't Lie."
Note: Talk presented at CppCon 2018 and Wargaming.net.
Note: Talk presented as keynote at Meeting C++ 2017 and C++ User Group, Russia.
Date: 2017-11-11
Abstract: A lightning talk demonstrating how to write a polymorphic task template (similar to std::function<>) with small object optimization in 10 minutes. The complete template is part of the stlab concurrency library and can be found here.
Erratum: The solution for the small object optimization presented in this talk relies on undefined behavior. A detailed explanation of the issue and a proper solution can be found here.
Note: The talk was presented as a lightning talk at Meeting C++ 2017.
Date: 2017-01-25, 2016-11-15, 2016-05-16
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 codebase.
Note: This is a revised version of the talk presented at ACCU Bay Area.
Note: This is a revised version of the talk presented at code::dive 2016.
Note: Talk presented as keynote at C++Now 2016 and ICPC 2016.
Date: 2017-01-18, 2016-10-10
Abstract: This talk explains why (and how) to implement non-intrusive polymorphism in C++. The talk contains many C++ tips and techniques, including many new features from C++11/14. During the talk, a key feature from Photoshop will be demonstrated and implemented. As part of my "Better Code" series of talks, the goal is "No Inheritance."
Note: This is a revised version of the talk presented at NDC { London } 2017.
Note: This is an updated version of the "Value Semantics and Concept-based Polymorphism" talk presented at Facebook.
Date: 2017-01-18, 2016-11-16, 2016-08-08, 2015-06-01, 2015-04-21, 2015-02-27
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. And then builds on the tasking system to develop a conceptual model for using futures and continuations and looks towards sequential communicating processes, higher level concurrent constructs. As part of my "Better Code" series of talks, the goal is to learn to write software that doesn't wait.
Erratum: I've incorrectly stated that std::async() changed with C++14.
Note: This is a revised version of the talk presented at NDC { London } 2017.
Note: This is a heavily revised version of the talk presented at code::dive 2016.
Note: This is the version of the talk presented at Bloomberg.
Note: This is an interview from CppCast about my talk.
Note: This is the version of the talk presented at the Bay Area C++ User Group Meeting.
Note: This is a video from the C++Now 2015. I believe the slides are the same as those listed above.
Note: 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-12-14
Abstract: A short lighting talk presented at the ACCU, Silicon Valley Chapter.
Date: 2016-08-08, 2015-09-23
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 objects. This talk looks at some of the ways 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.
Note: This is the version of the talk presented at Bloomberg.
Note: This is the version of the talk presented at CppCon 2015.
Date: 2016-01-10
Abstract: Sean Parent is a Principal Scientist at Adobe Systems, where he has worked on many of their digital imaging products. He managed the group that included Alex and Paul McJones while they were writing their book Elements of Programming. In this talk, Sean relates his memories of meeting Alex and working with him during Alex's Adobe years.
Note: This talk was presented at AlexFest.
Date: 2014-05-14
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 the 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
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 spice things up.
Note: 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
Abstract: Implementing non-intrusive runtime polymorphic objects with value-semantics and multiple-undo in 20 minutes.
Note: This is an abbreviated version of the Value Semantics and Concept-based Polymorphism talk linked below given at GoingNative 2013.
Date: 2013-09-06, 2012-05-18 Updated: 2013-09-24
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 that talk, a key feature from Photoshop will be demonstrated and implemented.
Note: Talk presented at C++Now 2012.
Date: 2013-03-05
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 look at how much things have changed and how a reset in our approach is needed.
Date: 2012-05-17
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?
Date: 2023-11-20
Authors: Jonathan Coe, Antony Peacock, Sean Parent
Abstract: We propose the addition of two new class templates to the C++ Standard Library: indirect<T> and polymorphic<T>.
Specializations of these class templates have value semantics and compose well with other standard library types (such as std::vector), allowing the compiler to correctly generate special member functions.
Date: 2021-04-14
Authors: Sean Parent
Abstract: The C++ Standard Library requirements are overly restrictive regarding the state of a moved-from object. The strong requirements impose an unnecessary burden on implementers and impose a performance impact on user-defined operations. This paper proposes relaxing the requirements by specifying what operations a moved-from object must be able to support.
Note: This paper is a C++ standard proposal, P2345.
Date: 2021-03-31
Authors: Sean Parent
Abstract: Written for Lakos, J., Romeo, V., Khlebnikov, R., & Meredith, A. (2021). Embracing Modern C++ Safely. Addison-Wesley Professional. A short chapter discussing problems with the C++ standard requirements for moved-from objects.
Date: 2016-07-18
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 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.
Note: This paper was presented at ECOOP 2016
Date: 2015-10-26
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 their 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 the 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.
Note: Paper presented at GPCE 2015.
Date: 2014-10-10
Authors: Eric Niebler, Sean Parent, Andrew Sutton
Abstract: This paper outlines what support for ranges in the C++ standard library might look like. Rather than presenting a final design, this paper proposes a set of concepts and guidelines for using them to implement range-based versions of the standard algorithms. It draws inspiration from the Boost Range library, the range algorithms in Adobe Source Libraries, Elements of Programming by Stepanov and McJones (2009), and from N3351 “A Concept Design for the STL” by Stroustrup and Sutton (2012). In addition to presenting the concepts and guidelines, this paper discusses the rationale behind each, weighing different design options.
Date: 2011-10
Authors: John Freeman, Jaakko Järvi, Wonseok Kim, Mat Marcus
Abstract: User interfaces exhibit a wide range of features that are designed to assist users. Interaction with one widget may trigger value changes, disabling, or other behaviors in other widgets. Such automatic behavior may be confusing or disruptive to users. The research literature on user interfaces offers several solutions, including interface features for explaining or controlling these behaviors. To help programmers help users, the implementation costs of these features need to be much lower. Ideally, they could be generated for free. This paper shows how several help and control mechanisms can be implemented as algorithms and reused across interfaces, making the cost of their adoption negligible. Specifically, we describe generic help mechanisms for visualizing data flow and explaining command deactivation, and a mechanism for controlling the flow of data. A reusable implementation of these features is enabled by our property model framework, where the data manipulated through a user interface is modeled as a constraint system.
Note: Paper presented at GPCE 2011.
Date: 2010-09
Authors: Peter Pirkelbauer, Sean Parent, Mat Marcus, Bjarne Stroustrup
Abstract: A key benefit of generic programming is its support for producing modules with clean separation. In particular, generic algorithms are written to work with a wide variety of types without requiring modifications to them. The Runtime concept idiom extends this support by allowing unmodified concrete types to behave in a runtime polymorphic manner. In this paper, we describe one implementation of the runtime concept idiom, in the domain of the C++ standard template library (STL). We complement the runtime concept idiom with an algorithm library that considers both type and concept information to maximize performance when selecting algorithm implementations. We present two implementations, one in ISO C++ and one using an experimental language extension. We use our implementations to describe and measure the performance of runtime-polymorphic analogs of several STL algorithms. The tests demonstrate the effects of different compile-time vs. run-time algorithm selection choices.
Data: 2009-10-04
Authors: Jaakko Järvi, Mat Marcus, Sean Parent, John Freeman, and Jacob N. Smith
Abstract: User interfaces for modern applications must support a rich set of interactive features. It is commonplace to find applications with dependencies between values manipulated by user interface elements, conditionally enabled controls, and script record-ability and playback against different documents. A significant fraction of the application programming effort is devoted to implementing such functionality, and the resulting code is typically not reusable.
This paper extends our "property models" approach to programming user interfaces. Property models allow a large part of the functionality of a user interface to be implemented in reusable libraries, reducing application-specific code to a set of declarative rules. We describe how, as a by-product of computations that maintain the values of user interface elements, property models obtain accurate information on the currently active dependencies among those elements. This information enables further expanding the class of user interface functionality that we can encode as generic algorithms. In particular, we describe automating the decisions for the enablement of user interface widgets and activation of command widgets. Failing to disable or deactivate widgets correctly is a common source of user-interface defects, which our approach largely removes.
We report on the increased reuse, reduced defect rates, and improved user interface design turnarounds in a commercial software development effort as a result of adopting our approach.
Note: Paper presented at GPCE 2009.
Date: 2009-06
Bjarne Stroustrup and I developed the syntax and semantics for the programming language described in the book Elements of Programming by Alexander Stepanov and Paul McJones. The language is a subset of C++ with a few extensions. The language is used to describe the algorithms in the book. This was influential in the development of the C++20 Concepts feature.
Date: 2008-10
Authors: Jaakko Järvi, Mat Marcus, Sean Parent, John Freeman, Jacob N. Smith
Abstract: A user interface, such as a dialog, assists a user in synthesizing a set of values, typically parameters for a command object. Code for "command parameter synthesis" is usually application-specific and non-reusable, consisting of validation logic in event handlers and code that controls how values of user interface elements change in response to a user's actions, etc. These software artifacts are incidental - they are not explicitly designed and their implementation emerges from a composition of locally defined behaviors.
This article presents property models to capture explicitly the algorithms, validation, and interaction rules, arising from command parameter synthesis. A user interface's behavior can be derived from a declarative property model specification, with the assistance of a component akin to a constraint solver. This allows multiple interfaces, both human and programmatic, to reuse a single model along with associated validation logic and widget activation logic.
The proposed technology is deployed in large commercial software application suites. Where we have applied property models, we have measured significant reductions in source-code size with equivalent or increased functionality; additional levels of reuse are apparent, both within single applications and across product lines; and applications can provide more uniform access to functionality. There is potential for wide adoption: by our measurements command parameter synthesis comprises roughly one-third of the code and notably more of the defects in desktop applications.
Note: Paper presented at GPCE 2008.
Date: 2008-03
Authors: Peter Pirkelbauer, Sean Parent, Mat Marcus, Bjarne Stroustrup
Abstract: A key benefit of generic programming is its support for producing modules with clean separation. In particular, generic algorithms are written to work with a wide variety of unmodified types. The Runtime concept idiom extends this support by allowing unmodified concrete types to behave in a runtime polymorphic manner. In this paper, we describe one implementation of the runtime concept idiom, in the domain of the C++ standard template library (STL). We describe and measure the performance of runtime-polymorphic analogs of several STL algorithms. We augment the runtime concept idiom by employing a dispatch mechanism that considers both type and concept information to maximize performance when selecting algorithm implementations. We use our implementation to demonstrate the effects of different compile-time vs. run-time algorithm selection choices, and we indicate where improved language and compiler support would be useful.
Date: 2007-01
Authors: Mat Marcus, Jaakko Järvi, Sean Parent
Abstract: A long-held goal of software engineering has been the ability to treat software libraries as reusable components that can be composed with program-specific code to produce applications. The object-oriented programming paradigm offers mechanisms to write libraries that are open for extension, but it tends to impose intrusive interface requirements on the types that will be supplied to the library. The generic programming paradigm has seen much success in C++, partly because libraries remain open to extension without imposing the need to intrusively inherit from particular abstract base classes. However, the static polymorphism that is a staple of programming with templates and overloads in C++, limits generic programming’s applicability in application domains where more dynamic polymorphism is required. In this paper we present the poly<> library, a part of Adobe System’s open source library ASL, that combines the object-oriented and generic programming paradigms to provide non-intrusive, transparent, value-based, runtime-polymorphism. Usage, impact on design, and implementation techniques are discussed.
From: The 6th International Workshop on Multiparadigm Programming with Object-Oriented Languages at the ECOOP 2007. Slides.
Date: 2024-03-08
In this episode, Conor and Bryce interview Sean Parent about Adobe Flash, his new library and idea called Chains and his latest thoughts on memory safety in programming languages and C++.
Date: 2024-01-05
In this episode, Conor and Bryce chat with Sean Parent about Jeri Ellsworth of Tilt Five, Greg Galanos of Metrowerks, Jean-Louis Gassée of Be Inc. and more!
Date: 2023-12-29
In this episode, Conor and Bryce chat with Sean Parent about Pascal, C, Unix, Modula(-2/3) and more!
Date 2023-12-15
In this episode, Conor and Bryce chat with Sean Parent about the latest on the Hylo programming language, potential limitations to the C++ Senders and Receivers model and the status of Rust and safety at Adobe.
Date: 2023-07-21
In this episode, Conor and Bryce close out their conversation with Sean Parent and learn why he left Apple to join Adobe.
Date: 2023-07-14
In this episode, Conor and Bryce continue their interview with Sean Parent live from C++ On Sea 2023 about the Val programming language!
Date: 2023-07-07
In this episode, Conor and Bryce interview Sean Parent live from C++ On Sea 2023 about the Val programming language and how it compares to Rust, Swift, and C++.
Date: 2023-06-02
Date: 2023-05-08
Date: 2022-11-09
This meeting features an AMA with Sean Parent!
Date: 2021-08-27
In this episode, Sean Parent tells the story of the battle between Project Star Trek and PowerPC.
Date: 2021-08-20
In this episode, Sean Parent tells the story of how Apple sued him, and Steve Jobs stepped in to save the day.
Date: 2021-08-13
In this episode, Bryce and Conor interview Sean Parent about restarting the Adobe Software Technology Lab.
Date: 2021-07-21
Rob and Jason are joined by Sean Parent and Dave Abrahams. They first talk to Dave about his history with C++, Boost, and the Swift programming language. Then, they talk with Sean and Dave about Adobe’s Software Technology Lab and their plans to focus on Concurrency in C++.
Date: 2021-06-04
In this episode, Conor and Bryce talk to Sean Parent about some of his Steve Jobs stories.
Date: 2021-05-28
In this episode, Conor and Bryce talk to Sean Parent about MacHack and how he got hired at Apple.
Date: 2021-05-21
In this episode, Conor and Bryce talk to Sean Parent about a plethora of topics, including slides, UI, and more.
Date: 2021-03-26
In this episode, we finish part two of our interview with Sean Parent!
Date: 2021-03-19
In this episode, we have our first guest - Sean Parent!
Date: 2019-10-17
Jon Kalb and Phil Nash interviewed me live at CppCon 2019.
Date: 2017-09-14
Jens Weller from Meeting C++ interviewed me leading up to my keynote.
Date: 2016-08-06
Jens Weller from Meeting C++ interviewed me following my C++Now keynote.
Date: 2015-06-01
An interview from CppCast about my talk.
Date: 1997-12
An interview published in MacTech.
Random sightings of me on the web.
Date: 2023-09-08
This episode references my ADSP interview, which discussed how Carbon almost didn't happen.
Date: 1992
Somehow, I convinced Apple to allow me to bring a prototype of the RISC-based Macintosh to MacHack 1992. This unit used an M68110 with an emulator written by Gary Davidian. We did not yet have a prototype with a PowerPC processor. I offered $100 to anyone who could find a piece of Mac software that would not run on the prototype. Waldemar Horwat won the $100 by finding that the TMON debugger did not run under emulation. The video from MacHack is unwatchable but captures me presenting the payment to Waldemar.
On the same unwatchable video is a clip of me presenting my hack, Okay, What was that?
Some of my older papers and presentations can be found here.