rf engineering

Glenn Vanderburg argues at Lone Star Ruby Conference 2010 that university-style software engineering does not work, and asks what real software engineering would look like. He revisits the waterfall model and what engineering means in other fields.

Chris Domas's DEF CON 23 talk on psychological warfare against reverse engineers. He builds code whose disassembly and control flow graphs mislead, intimidate and demoralize anyone analyzing it.

Chris Lattner and Brennan Saeta present Swift for TensorFlow at the TensorFlow Dev Summit 2019, covering language-integrated automatic differentiation and tooling for machine learning in Swift.

Chandler Carruth's CppCon 2014 talk on writing fast C++, explaining why data structure choice and memory layout matter more than clever algorithms. It covers why standard containers like unordered_map perform poorly on modern CPUs.

Bryan Cantrill's Monktoberfest 2016 talk on how software engineers pass knowledge down through oral tradition, from folk rhymes to programmer lore and stories like why C lacks a logical XOR. He argues for writing software with future generations in mind.

Investigative journalist Sharyl Attkisson explains how astroturf, fake grassroots campaigns funded by corporate or political interests, manipulates media messages. The TEDx talk is about 11 minutes.

Glenn Vanderburg asks whether software development can be real engineering, surveying other engineering disciplines and decades of programming experience. He envisions what a software engineering worthy of the name might look like.

Glenn Vanderburg argues at the O'Reilly Software Architecture Conference that software development is an engineering discipline, even if immature. He contends the discredited body of knowledge called software engineering has led people to wrongly reject the label.

Joel Spolsky's 2009 Google Tech Talk on why StackOverflow was built, how it addresses the mess of searching for programming help, and the community design behind it. He also takes jabs at paywalled answer sites.

A Netflix performance engineer presents how Netflix tunes EC2 instances, covering instance type choice, Xen modes, SR-IOV and kernel tuning. The goal is near bare-metal performance in the cloud.

A Google Tech Talk on Yahoo's 14 rules for faster web pages and the YSlow tool. It covers front-end practices like avoiding @import and fixing ETags, with live analysis of popular sites.

Malte Skarupke's C++Now 2018 talk on hash table performance, explaining why std::unordered_map is slow and memory hungry and presenting faster designs, including his bytell hash map.

Emery Berger's CppCon 2020 plenary on why performance is hard on modern hardware after the end of Dennard scaling. It covers benchmarking pitfalls and introduces new profiling tools for finding real bottlenecks.

The fail0verflow 27C3 talk on breaking PS3 security, covering how Sony's implementation failed, including its ECDSA mistakes.

Michael Steil's 27c3 talk on reverse engineering the MOS 6502 from die shots into a transistor-level simulation, as in the Visual6502 project. It covers going from chip package to a digital model.

Bryan Cantrill's Craft 2019 talk on the ethical dilemmas software engineers face as software eats the world. He explores cases where engineering thinking conflicts with the law or personal morals, including Facebook's news feed experiments.

A Microsoft Research talk on BetrFS, a file system built on B-epsilon trees, a write-optimized data structure. It covers WODS such as LSM-trees, how to design a file system around them, and benchmark wins over ext4 and xfs.

Bryan Cantrill's Monktoberfest 2023 talk takes on AI doomerism, weighing the theoretical existential risks against the reality on the ground. He takes a skeptical but thoughtful view of how to balance AI's potential against its risks.

Emery Berger explains why performance is hard to measure and deliver on modern hardware, showing how code layout and alignment can swamp optimization effects. He presents Stabilizer for statistically sound evaluation and Coz, a causal profiler.

Bryan Cantrill's Monktoberfest 2017 talk on leadership and organizational principles, ranging from the Gettysburg Address to Uber and Amazon. He argues for the difference between principles and values and criticizes vague corporate principles.

Optiver's Carl Cook explains how to build high-frequency trading systems in C++, where the critical path runs rarely but must be extremely fast. He covers techniques for low and predictable latency, including avoiding main memory and cache misses.

Richard Feldman explains how pure functional languages can match or beat imperative ones on performance. Compilers can turn immutable code into in-place mutation, avoiding naive copying. The talk draws on his work on the Roc language.

Alex Russell's Chrome Dev Summit 2016 talk on building web experiences that work on slow, flaky networks and low-power devices. It argues developers should focus on the performance of real-world mobile hardware rather than desktop machines.

Emery Berger argues that performance is hard to measure and deliver on modern systems, showing how code layout and link order can swamp optimization effects. He presents tools that evaluate performance more reliably.

Chandler Carruth walks through tuning C++ performance, from writing benchmarks to analyzing results on real CPUs and compilers. It focuses on small-scale problems such as loop kernels, data structures and algorithms, and on keeping compilers from optimizing benchmarks away.

Cliff Click walks through a small performance example on a modern out-of-order CPU. He covers pipelining, ILP, CISC vs RISC, multicore, and why cache misses and the memory subsystem dominate performance.

A 2009 Google Tech Talk by Nicholas Zakas on the hidden performance pitfalls of JavaScript. It covers what is fast and slow in the language and how to avoid common bottlenecks.

Greg Wilson surveys what empirical research actually shows about software development, why we believe it, and how to share that knowledge more widely. It covers evidence on practices such as TDD and design patterns.

Hamish Coleman describes reverse engineering the keyboard controller in a Thinkpad and reflashing it with custom firmware. He covers how Lenovo secures its firmware, and his ongoing work on the protocol between the BIOS and the vendor flash tool.

Stuart Armstrong of the Future of Humanity Institute gives an Oxford physics talk on what exploratory engineering suggests about the Fermi paradox. He argues that von Neumann probes and Dyson spheres are plausibly buildable and asks what traces advanced civilizations would leave.

Alex Ionescu's OffensiveCon 2019 keynote on how reverse engineering is done on Windows without conventional reversing. It covers legal ways to obtain names of variables, exported functions and structures.

Erik Meijer argues that category theory is the mathematicians' version of interface-based design. He shows that Java 8 lambdas and method references form a Cartesian closed category.

Chandler Carruth's CppCon 2016 talk on designing hybrid data structures for performance. He covers cache locality, working-set size and allocation overhead, and why standard C++ containers fall short.

Rasmus Lerdorf marks 25 years of PHP at phpday 2019 with a look at the highlights and lowlights of the language. He argues for upgrading PHP versions, covering performance, static analysis, zero-cost profiling and dead code elimination.

Stavros Korokithakis gives a FOSDEM 2018 talk on how hard it is to validate email addresses properly, taking a tour through RFC 5321.

A JSConf 2014 talk visually breaking down algorithms behind everyday UI patterns, such as dropdown menus that vanish when the mouse drifts and picking the nearest target to the cursor. It shows how these are implemented in JavaScript.

Christopher Domas's REcon 2013 talk on dynamic binary visualization for reverse engineering. He shows how rendering binary data as interactive visual maps and trigraphs reveals structure that hex dumps hide, leading to his Cantor.dust tool.

Aaron Hsu shows how to manipulate and transform tree data in APL using arrays and inverted tables instead of pointers. He claims much smaller code, better performance and easier parallelisation.

Jayson E. Street's DEF CON 19 talk shows photos from real security engagements where he was already inside client facilities, illustrating how social engineering and physical intrusion can cause huge losses. For each attack he also explains what defenses would have stopped him.

Leptos creator Greg Johnston examines Rust/WebAssembly frontend frameworks against JavaScript frameworks using the JS framework benchmark. He argues that WASM is no longer too slow for DOM-heavy rendering.