The Mechanics of Creation

Thoughts, ideas, reflections

Talks

If you are interested in inviting me to speak at your event, please see my Speaker Page for more information.

Upcoming talks

June 2016: QCon NYC

August 2016: Midwest.io

September 2016: StrangeLoop

October 2016: JAX London

Past talks

May 2016: GOTO Chicago

In my talk Building a Distributed Build System at Google Scale I discussed what it means to build systems at Google scale and described the evolution of the developer workflow that leads to the need for a distributed build system. I concluded with the discussion of challenges of migrating systems from one distributed architecture to another, with examples from Google, and presented how we succeeded at launching the new architecture with zero downtime. (Slides)

Video coming soon.

April 2016: Clojure/West 2016

The talk (+ Loom (years 2)) covered the last 2 years of development in Loom, including its API evolution and the additional algorithms. I also discussed the tradeoffs I had to make as a maintainer of the library and the way I balanced my open-source work with my other life responsibilities. (Slides)

March 2016: QCon London

I discussed the 3 architectural patterns, Staged Event-Driven Architecture, distributed leases, and inaccurante computations, and demonstrated the examples of applications of these patterns from the systems I’ve worked on at Google in my Distributed Systems in Practice, in Theory talk. The video will become available publicly in the next few months. (Slides)

October 2015: Papers We Love San Francisco

I presented the paper Probabilistic Accuracy Bounds for Fault-Tolerant Computations that Discard Tasks at Papers We Love Too (SF) session. We discussed the field of inaccurate computations that allows us to have more robust computations at the cost of some inaccuracy. (Slides)

October 2015: JAX London 2015

I gave the longest version of my best practices in benchmarking talk at JAX London 2015. (Slides)

May 2015: LambdaConf 2015

In the "Loom and Functional Graphs in Clojure" talk at LambdaConf 2015, I discussed how graphs are represented in functional languages, bridged the gap between procedural description of graph algorithms and their functional implementation. In addition, I presented how Loom defines graphs and due to its flexible API integrates easily with other graph representations. (Slides)

April 2015: Cognicast Episode 76

I had a great time talking with Craig Andera on Cognicast about art, Loom, and trying new things.

March 2015: DevNexus 2015

I gave a talk on best practices in benchmarking systems at DevNexus 2015. The talk is a 50-minute version of the previous talks and goes into more examples and profiling tools available in different ecosystems. After the talk, I gave an interview on NightHacking on benchmarking, art and music. (Slides)

December 2014: Papers We Love Google

I presented the paper Copysets: Reducing the Frequency of Data Loss in Cloud Storage at Google’s internal Papers We Love session, in which we read and discuss Computer Science and industry papers and which I organize. During the session, we discussed replication algorithms, chainsets, derandomization techniques and many other related topics. No video is publicly available.

October 2014: RICON 2014

I gave a talk on best practices in benchmarking distributed systems at RICON 2014. In the talk, I focused on three areas of common pitfalls: how machines work, statistics, and what matters when setting up a benchmark. In addition, I discussed strategies to write better benchmarks and briefly touched on the subject of microbenchmarks. (Slides)

Benchmarking You’re Doing It Wrong

September 2014: StrangeLoop 2014

I gave a talk on best practices in benchmarking systems at StrangeLoop 2014. The talk addressed common pitfalls software engineers make when reasoning about how machines work, statistics and interpretation of results, and setup of a benchmark to measure relevant information. I also covered common pitfalls when performing microbenchmarks. (Slides)

June 2014: Papers We Love NYC

I presented a paper on compiler and virtual machine technology, One VM to Rule Them All by Thomas Würthinger, Christian Wimmer, Andreas Wöß and others, at the Papers We Love NYC meetup. The paper explains how you can write an interpreter and get an optimizing just-in-time (JIT) compiler for free. This enables language designers to focus on features without worrying about the complexities of compiler optimizations and code generation. This paper presents a Java Virtual Machine (JVM) that allows the application to control the JIT compiler behavior at runtime. We’ll discuss how various programming languages can take advantage of this framework. After presenting the paper, I facilitated the discussion on implementing various languages using the Truffle/Graal framework and many other related topics. (Slides)

March 2014: Clojure/West 2014

The talk at Clojure/West featured Loom, a graph algorithms and visualization library written in Clojure. In this talk, I presented Loom’s simple graph API, discussed how to implement graph algorithms functionally by demonstrating Bellman-Ford algorithm’s procedural pseudo-code and functional implementation in Clojure. In addition, I demonstrated the ease of integrating Loom with other graph representation by showing how to run graph algorithms on data stored in Titanium graph database, visualizing core.async’s “go” macro’s state machine, and analyzing popularity of Clojure projects on Github.(Slides)

Graphs are ubiquitous data structures and the algorithms for analyzing them are fascinating. Loom is an open-source library that provides many graph algorithms and visualizations. We will discuss the graph API, look at the implementations of the algorithms and learn about the integration of Loom with other graph representations. We will specifically look at integrating Loom with Titanium to run graph algorithms on graph databases, core.async to visualize the “go” macro’s state machine, and Github data to analyze Clojure projects.

August 2013: LispNYC

I presented Loom, its graph API and implementations of graph algorithms at LispNYC meetup.

Slides: slideshare.net/aysylu/aysylu-loom Source code: github.com/aysylu/loom