Getting exception handling right is a perennial problem in C++ that has eluded systematization. Not for much longer. New language and library developments make it possible to handle exceptions in a declarative manner, leading to drastic code simplification.
This talk discusses an alternative approach to handling exceptional flow that eliminates the need for small ancillary RAII classes, try/catch statements that rethrow, and other cleanup mechanisms. The popular Scope Guard idiom gets a spectacular generalization. Statements specify in a declarative manner actions to be taken if the current scope is left normally or via an exception. The resulting code is simpler, smaller, and easier to maintain.
Review ScopeGuard's pros and cons
Stay abreast of proposed language improvements for better error handling
New implementation-specific extensions to scope guards
Use of the new SCOPE_FAILURE and SCOPE_SUCCESS abstractions that complements the existing SCOPE_EXIT
ScopeGuard is of interest to C++ programmers of all levels. Implementation details are appealing to advanced engineers.
Action/Next/Cleanup/Rollback idiom overview in several languages
Composition with said idiom
Explicit vs. implicit control flow as a riff on declarative vs. imperative programming
Order Still Matters
There's a freaking supercomputer in your browser, and nobody seems to have noticed!
You've heard that WebGL is for games and pretty 3D graphics? That's merely the beginning. It also lets you write arbitrary GPU code and thereby wield insane computational power for any purpose. And yes, it works in Firefox, Chrome, and IE, without plugins, today. What new categories of web apps and web businesses will this enable?
Starting with a gentle introduction to 3D with WebGL (via the lovely Three.js library), this demo-led talk will take you deeper, into the GPU itself. You'll see:
GPU coding basics - how the parallel execution is structured, and the GLSL language (don't be scared - it looks like C, and runs right in the browser)
How to make your GLSL code screamingly fast and not crash the browser tab
Plenty of demos including 3D visualisation, realtime client-side media processing, and object recognition
By the end of this talk, I hope you'll be inspired to try something new in your next web app.
If you're making WPF or WP or even Monotouch and Monodroid applications these days, you're probably familiar with using MVVM to structure your apps. But what happens when you blend the asynchrony and composability of Reactive Extensions with the MVVM pattern? You get ReactiveUI! In this talk I'll introduce the fundamentals of ReactiveUI, dig into the benefits and tradeoffs, and demonstrate some cool tricks that might make your bespoke framework look archaic.
Habits help you manage the complexity of code. You apply existing skill and knowledge automatically to the detail while focusing on the bigger picture. But because you acquire habits largely by imitation, and rarely question them, how do you know your habits are effective? Many of the habits that programmers have for naming, formatting, commenting and unit testing do not stand up as rational and practical on closer inspection.
This talk examines seven coding habits that are not as effective as programmers believe, and suggests alternatives.
Most people believed, incorrectly as it turned out, that Ada and PL/1 would dominate the future. But I was more interested in Prolog and Smalltalk. Prolog was the answer, but I didn't know what the question was. I'll talk about how we grew a programming language, and what the main factors were in spreading the language. I'll relate my personal experience with Erlang to broader developments in programming and try to see how the two fit together. I'll also take a peep into the future and speculate about where computing is going.