18 - 19 Oct '18 Sydney, Australia

Sharing knowledge and building a network of great C++ developers in the Asia-Pacific region.

Tickets


HOT!
Conference Pass
  • Two day pass
  • Coffee, snacks and lunch included
Buy now!

Ticket sales close midnight 30th September or if sold out


Got tickets? Let others know they can meet you there.

C++ meets Asia Pacific

A two day conference for C++ professionals and enthusiasts.


As an attendee, along with networking opportunities, you will be learning from a number of talks which fit into the following categories:



Become a speaker

Submissions are now closed for the 2018 conference.

Code of Conduct

Pacific++ is dedicated to providing a harassment-free conference experience for everyone, regardless of gender, sexual orientation, disability, physical appearance, body size, race, religion or political affiliation.

Harassment includes, but is not limited to:

  •   Offensive verbal comments related to gender, sexual orientation, disability, physical appearance, body size, race, religion or political affiliation
  •   Displaying sexual images
  •   Deliberate intimidation, stalking, or following
  •   Unwanted photography or recording
  •   Sustained disruption of talks or other events
  •   Inappropriate physical contact
  •   Unwelcome sexual attention

All communication should be appropriate for a professional audience including people of many different backgrounds. Be kind to others. Do not insult or put down other attendees. Sexual language and imagery is not appropriate for any conference venue, including talks. Excessive swearing and offensive jokes are not appropriate for Pacific++.

We do not tolerate harassment of conference participants in any form. If a participant engages in behavior that violates this code of conduct, the conference organizers may take any action they deem appropriate, including expulsion from the conference with no refund. Participants asked to stop any harassing behavior are expected to comply immediately.

Thank you for helping make this a welcoming, friendly event for all.

Reporting

If you are being harassed, notice that someone else is being harassed, or have any other concerns, you can either:

  •   Speak with conference staff (identifiable by 'Staff' lanyard)
  •   Email the conference organiser [email protected]
  •   Anonymously report the incident here

All reports and concerns are kept confidential.

Conference staff will be happy to help participants contact hotel/venue security or local law enforcement, provide escorts, or otherwise assist those experiencing harassment to feel safe for the duration of the conference. We value your attendance.

License and Attribution

This is version 1.0 of the Pacific++ Code of Conduct. It is licensed under the Creative Commons Attribution 3.0 Unported License. It is a derivative of the C++ Code of Conduct, which is itself a derivative of the PyCon Code of Conduct and the Geek Feminism wiki.

0

speakers

0

days

0

keynotes

Speakers

Meet our speakers scheduled to appear



Keynote

Sean Parent

SEAN PARENT

Adobe - United States

Keynote Sponsored by Wargaming Sydney

Sean Parent is a principal scientist and software architect for Adobe Photoshop. Sean has been at Adobe since 1993 when he joined as a senior engineer working on Photoshop and later managed Adobe’s Software Technology Lab. In 2009 Sean spent a year at Google working on Chrome OS before returning to Adobe. From 1988 through 1993 Sean worked at Apple, where he was part of the system software team that developed the technologies allowing Apple’s successful transition to PowerPC.

Keynote

Titus Winters

TITUS WINTERS

Google - United States

Titus is a Senior Staff Software Engineer at Google, where he has worked since 2010. He leads Abseil, Google’s open-source C++ library that underpins more than 250M lines of Google code with 12K+ active internal users. He is one of the four arbiters for Google’s official C++ style guidelines. For the last 7 years, Titus has been organizing, maintaining, and evolving the foundational components of Google’s C++ codebase using modern automation and tooling. Titus chairs the Library Evolution Working Group (LEWG) for the C++ Standard - the group responsible for API design proposals to the standard library. He is also chairing the newly-formed SD15 for discussions of Tooling in the C++ ecosystem.

Plenary

Kate Gregory

KATE GREGORY

Canada

Kate Gregory has been using C++ since before Microsoft had a C++ compiler, and has been paid to program since 1979. She writes, mentors, codes, advises teams, and leads projects, focusing on C++. Kate is a Microsoft Regional Director, a Visual C++ MVP, an Imagine Cup judge and mentor, an active contributor to StackOverflow and other StackExchange sites, has written over a dozen books, and speaks at conferences and user groups around the world. She develops courses for Pluralsight, primarily on C++ and Visual Studio. Since its founding in 2014 she has served on the Planning and Program committees for CppCon, the largest C++ conference ever held, where she also delivers sessions.

Plenary

James McNellis

JAMES McNELLIS

Microsoft - United States

James McNellis is a Principal Software Engineer at Microsoft where he works on the Time Travel Debugging (TTD) reverse debugging toolkit. Prior to joining the Windows Debuggers team in 2016, he worked on the Visual C++ team and was responsible for the Microsoft C Runtime (CRT) and C Standard Library implementation. Passionate about all things related to C++, he is a frequent speaker at C++ conferences around the world and is a former top contributor on StackOverflow.



Toby Allsopp

Toby Allsopp

WhereScape Software - New Zealand

Toby is the organiser of the Auckland C++ Meetup. He is a Senior Software Engineer at WhereScape Software in Auckland, New Zealand and has previously held titles including Software Architect and Team Lead. He has been using C++ both professionally and recreationally for 20 years or so and remains undeterred. When not programming, Toby enjoys skiing, reading about programming, watching cricket, talking about programming, and drinking craft beer.

Christopher Di Bella

Christopher Di Bella

Codeplay - Scotland / Australia

Christopher Di Bella is a Staff Software Engineer for Codeplay’s ComputeCpp Runtime Technology and a C++ teacher. He advocates for including the Concepts TS and the Ranges TS in C++20. Chris spends his days working on ComputeCpp, Codeplay’s implementation of SYCL, a Khronos Standard for heterogeneous programming in C++; the Khronos implementation for the Parallel STL (using SYCL); and researching Parallel Ranges, which is an attempt to fuse ranges together with the parallel STL. Chris was previously a software developer for Nasdaq, and a tutor for UNSW Sydney’s advanced C++ and compiler courses. In his spare time, Chris enjoys snowboarding, playing games, and watching films.

James Mitchell

James Mitchell

Wargaming - Australia

James is an Expert Software Engineer at Wargaming Sydney with over 15 years’ experience using C++. For the last 6 years, he has been building high performance distributed server technology, including BigWorld Technology the online game engine used to power many of Wargaming's titles, including World of Tanks, World of Warships, and World of Warplanes.

Scott McMillan

Scott McMillan

Wargaming - Australia

Scott McMillan is an Expert Software Engineer at Wargaming Sydney. Scott has spent four years at Wargaming, working on game engine architecture and render systems using c++. He has also spent 8 years using c++ in a games and HPC setting whilst working on Depth Analysis' MotionScan product, as seen in L.A. Noire. He has a love for performance optimization; something that's often needed in low-level game engine work. Scott is passionate about the c++ language and utilizing it most effectively to engineer effective high-performance solutions.

Klemens Morgenstern

Klemens Morgenstern

Freelance - Malaysia

After going into electrical engineering Klemens remembered that C++ development is just way more fun, especially in bare-metal applications. If necessary he's also using operating systems, especially when he can design libraries around it. He is active in several open-source projects and does freelance C++ consulting.

Andrew Paxie

Andrew Paxie

Crown Equipment Corporation - New Zealand

Andrew Paxie is a software engineer in the Robotics Technology Centre of Crown Equipment Corporation, where he has worked since mid-2012. At Crown, Andrew has driven the adoption of modern C++ in the core code base. He has applied and promoted static and dynamic analysis tools to improve code quality, and introduced other quality improvements through unit test and code coverage tools. Andrew maintains the site-wide C++ Coding Guidelines. Andrew wrote his first "Hello, world" C++ program over twenty-five years ago and is currently a collaborator on the Trompeloei mock object framework with Björn Fahller and other contributors.

Alexander Radchenko

Alexander Radchenko

Optiver - Australia

Alexander Radchenko joined Optiver as a senior developer in 2016. His job is to write and optimise low latency trading platforms. Algorithmic trading is a world where performance is critical, which provides exactly the kinds of problems that Alexander loves to solve. Prior to joining Optiver, he was developing video games for 15 years on all major platforms. He has multiple shipped games under his belt, including massive online shooter World of Tanks. Alexander specialises in systems programming and optimization. Nothing is better than converting a big, sluggish piece of software into a lean, fast machine.

Kirit Sælensminde

Kirit Sælensminde

Proteus Technologies - Thailand

Kirit is a partner at Proteus Technologies, a Thai software services company serving clients worldwide. He has been working with and teaching C++ since the mid-90s and currently works on architecture and security across all of his company's projects. Before moving to Thailand he ran computer graphics and software services companies in London where he grew up.

Nick Uhlenhut

Nick Uhlenhuth

Microsoft - United States

Nick Uhlenhuth is a Program Manager on the Visual C++ team at Microsoft. He is responsible for designing new and improved productivity features for C++ developers in Visual Studio. Before joining the Visual C++ team, he was a program manager in Microsoft's Threat Intelligence Center where he helped identify trends in cyber threats. Have any suggestions for how Visual Studio can make your C++ development easier? Be sure to let him know!

Schedule

Click on a talk title for more details

Note: Schedule may change without notice

 8:15AM
Conference Open
 9:00AM
Welcome

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. 30 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.

Sean Parent
 10:30AM
Morning Break

Performance is one of the primary reasons developers use C++ today.
This talk is about analyzing performance of C++ applications in two different yet similar domains: game development and low latency algorithmic trading
It will cover understanding performance profile of C++ application hot path and visualizing performance patterns.
You will see how performance can be measured in production and controlled lab environments.
Talk is quite practical with concrete ideas everyone will be able to take home and apply straight away.

Alexander Radchenko
 12:00PM
Lunch

Think global variables are always bad? Do you fight with dependency injection, context objects, singletons, etc? We will look at why global variables have such a bad rap, and why I believe they still deserve a seat at the table.

James Mitchell

With the ideal of writing portable C++ we need libraries to provide access to the system facilities. Keeping the C++ ideals, low overhead and only paying for what you use, does pose non-trivials problems. Not only are concepts like filesystems implemented differently, but these concepts themselves might not be platform independent, like posix-signals.

Klemens Morgenstern
 3:15PM
Afternoon Break

Many people say that simple code is better code, but fewer put it into practice. In this talk I’ll spend a little time on why simpler is better, and why we resist simplicity. Then I’ll provide some specific approaches that are likely to make your code simpler, and discuss what you need to know and do in order to consistently write simpler code and reap the benefits of that simplicity. Code samples will be in C++ and some material will be C++-specific.

Kate Gregory
 5:00PM
Closing Notes

C++17 introduced parallel algorithms, but the current interface prevents heterogeneous systems -- such as personal computers and server nodes with GPUs, smartphones, and embedded System on a Chip -- from taking advantage of parallel computation. Through its clean, algorithmic composition, we believe that the Ranges TS and its proposed extensions offer solutions to these problems, and how well programs perform on heterogeneous platforms.
We will discuss why adopting Ranges will be beneficial for your programs, and once parallelised, how they naturally lend themselves to parallelising your code with minimal changes on your part.

Christopher Di Bella

Programming is composition; we compose expressions into statements, statements into functions, functions into modules, modules into programs, programs into systems. Often, the way in which our code is composed is buried in the details. We write glue code that ends up duplicating and spreading out the ways in which our programs are composed. This can obscure the structure of the program and make it difficult to reason about.
In this talk I will describe some common compositional patterns and show how they can (or can't) be made explicit in C++. We'll talk about composition at all levels of a C++ program, with a particular focus on functions and algorithms.
My objective is to give you a new perspective on the structure of your C++ programs and to offer you some terminology to use when talking about the compositional patterns that you use. I also hope to encourage you to make composition explicit in your code when the language allows it, but that is not necessary in order to benefit from this talk.

Toby Allsopp

Trompeloeil is a C++14-first mock object framework. In this talk I will show you how I backported it to C++11. In detail, I will

  • Discuss motivation for this work.
  • Present a brief overview of the library's features.
  • Discuss library- and language-specific changes and support these with code snippets.
  • Cover unit testing approaches and multi-platform issues.
  • Reveal compromises and limitations to backported functionality.
  • Outline alternatives to this approach.
  • Answer the question: How do I "port" a C++11 program to C++14?

Andrew Paxie
 8:15AM
Conference Open
 9:00AM
Welcome

Over the last 35 years, C++ has remained a constant fixture in the programming landscape. With advancements in the language through C++11, 14, and 17, we've created new dialects that have breathed new life into C++. With C++ Core Guidelines and a rich community of authors and speakers providing guidance on C++, it is easier now to steer clear of problem areas and hopefully stay in the "good parts" of the language.
Or at least, that's what we'd like. In practice, many habits of C++ programmers are unsafe and will be hard to keep working. The triple perils of ADL, ODR, and ABI leave a wide assortment of pitfalls for code maintenance. Many systems happen to work, but perhaps more out of luck than actual correctness.
How do we explain this dichotomy? How is the language better than it ever has been, and at the same time so dangerous and burdened with silent pitfalls and legacy? Can the standard evolve over time to reduce these perils? More importantly: should it?
In this talk I'll remind people of how precarious most C++ code is in the face of change (like advancing to a new language version), and discuss the most fundamental issue facing the committee these days: how to balance between the legacy code of the past and the yet-to-be-written code of the future.

Titus Winters
 10:30AM
Morning Break

Creating cutting-edge games requires engineering for high performance in order to maximize gameplay features and graphical fidelity. Understanding the cache and memory subsystems is a critical part of this.
This talk provides an overview of some of the relevant issues to consider in this area, and how we can design c++ applications to deal with these issues efficiently. There is a focus on aspects that have been particularly important for our work at Wargaming developing games, but the techniques and approaches are widely applicable.

Scott McMillan
 12:00PM
Lunch

Writing high-quality error-free C++ code itself is a challenging task, let alone when having to juggle multiple platforms at the same time! In this session, I will talk about many challenges in cross-platform C++ development and how tools can help: what options do I have if my production environment is different than my dev box? Can I be as productive when working with remote Linux machines? Is there any good C++ editor that works consistently on all platforms I work on? How can I efficiently build and debug CMake projects, or even get IntelliSense? How can I easily find and acquire open sourced libraries? Is there an easy way to write and run cross-platform tests? Come to see what Visual Studio 2017, Visual Studio Code, CMake, WSL, Vcpkg and more have to offer to make cross-platform C++ development much easier in this demo-heavy talk.

Nick Uhlenhuth

Getting good performance out of your APIs isn't only about supporting move semantics properly. Especially for APIs used in inner loops, it's important that the API and the implementation co-operate in order maximise performance.
This talk will start with some simple places where a small tweak to an API can potentially double performance, and then show how larger structural changes can speed code by even larger factors. It will also suggest a few places where the standard library can be improved to help.

Kirit Sælensminde
 3:15PM
Afternoon Break

We’ve all heard horror stories about bugs that were near-impossible to root-cause, and many of us have at least a few stories of our own. Time Travel Debugging (TTD) is a reverse debugging toolkit for Windows that makes debugging these kinds of problems far easier, in both small programs and commercial-scale software like Windows and Office. It enables you to record bugs as they happen, then replay the recording in the debugger afterwards, and use most of the debugger features that are available when debugging a live process.
In this session, I’ll introduce what Time Travel Debugging is and demonstrate both how to record execution of a program and how to debug the resulting recording. We’ll walk through the root cause analysis of some typically difficult-to-solve bugs like memory corruption and API misuse. Finally, we'll look at TTD’s advanced querying capabilities, which let you query information about memory accesses and function calls. As we walk through the examples, I’ll also introduce other, related debugger features that make debugging easier in general, even when not using Time Travel Debugging.

James McNellis
 5:00PM
Closing Notes

Sponsors

Companies and organisations who support Pacific++.



Gold

Bronze

Community

If you would like to support this conference, send us an email to receive a sponsorship information pack.