Goto London Day 1 Keynote
gotocon.com/goto-london-2015
https://github.com/Randommood/GotoLondon2015
Surprisingly enough academic papers can be interesting and very relevant to the work we do as computer science practitioners. Papers come in many kinds/ areas of focus and sometimes finding the right one can be difficult. Websites like The Morning Paper (http://blog.acolyer.org/) and organizations like Papers We Love (http://paperswelove.org/) aim to bring research closer to practitioners and we want you to be a part of them!
Join us for a guided tour of our favorite agile, lean, and rugged papers. We will explore papers that have laid the foundation of Computer Science and papers that push the boundaries of what we know using the three themes of our conference as guide.
The popularity of implementing microservices in today’s application landscape continues to rise, and there have been countless success stories focused on migrating from monoliths to microservices. But as more teams move toward microservices architectures, an increasing number of stories have arisen about the pain of poor choices. Microservices are not the answer to all application problems. Attempts to move away from one giant application to smaller focused services often result in a tightly coupled nest of applications.
Blithe Rocher covers some of the pitfalls and lessons learned from building several service-oriented systems. Blithe explores some of the problems with building, testing, and deploying a functional microservice architecture, from data loss to dependency nightmares, drawing on war stories she has collected and from her own personal experience. You’ll come away with some valuable lessons about microservices without having to go through the pain of experiencing them yourself.
We all want to move fast. We construct our systems in a rapidly-iterating and agile way. Ideally we design and build them to be efficient, robust, and have low latency. But sometimes in the search for speed we make mistakes that come back to haunt us.
The talk is about the things most of us sacrifice when trying to iterate fast. Some of these are reasonable trade-offs — others can wreck your product. I hope you will walk away with a notion of what to pay attention to at various stages of software development, and how you can avoid common pitfalls.
Top 5 Things I've Messed Up in Live StreamingFastly
June 24, 2014 - SF Video Technology Meetup. Live streaming can be difficult and challenging, yet extremely rewarding. In the video gaming world, it has become the most powerful way of reaching your audience. It combines traditional web technologies with even more traditional broadcast video stacks in a "it's going live now" environment. In this presentation Lee Chen, head of product at Fastly, goes over the top 5 things that have lost him sleep, made his eyebrows go up, and sometimes even made him fail -- what he did to correct it.
From list sorting to network routing, and from hash tables to capacity planning, a programmer's daily work is filled with probability. We use probabilistic algorithms, data structures, and systems constantly often without even thinking about it. Experienced engineers reach for probabilistic algorithms frequently and intentionally, especially when building systems of serious scale. How do probabilistic algorithms actually work in practice? And how do we know they'll be safe and reliable in our critical production systems? We'll address those questions, explore a few algorithms, and see why "with high probability" is often better than "exactly".
Racing To Win: Using Race Conditions to Build Correct and Concurrent SoftwareFastly
If you've ever worked on parallel or multiprocessor software, you've almost certainly encountered bugs owning to race conditions between concurrently-executing components. While race conditions intuitively seem bad, it turns out there are cases in which we can use them to our advantage! In this talk, we'll discuss a number of ways that race conditions are used in improving throughput and reducing latency in high-performance systems, without sacrificing correctness along the way.
We'll begin this exploration with a discussion of how various mutual exclusion primitives like locks are implemented efficiently in modern hardware using benign race conditions. From there, we'll investigate how one can implement non-blocking algorithms and concurrent data structures in a correct and deterministic manner using freely-available open source libraries.
The Fallacy of Fast - Ines Sombra at Fastly Altitude 2015Fastly
Fastly Altitude - June 25, 2015. Ines Sombra, a Systems Engineer at Fastly, talks about lessons learned in rapid systems development.
Video of the talk: http://fastly.us/Altitude2015_Fallacy-of-Fast
Ines' bio: Ines Sombra is a Systems Engineer at Fastly, where she spends her time helping the Web go faster. Ines holds an M.S. in Computer Science and an M.S. in Information Management from Washington University in Saint Louis. Being a true Argentine, she has a fondness for steak, fernet, and a pug named Gordo.
Design & Performance - Steve Souders at Fastly Altitude 2015Fastly
Fastly Altitude - June 25, 2015. Chief SpeedCurver Steve Souders explains how design and web performance are more interconnected than ever before. Users want a fast website with a rich design, but sometimes the interplay between design and performance feels like a fixed sum game: one side's gain is the other side's loss. Design and performance are indeed connected, but it's more like the yin and yang. They aren't opposing forces, but instead complement each other. Bringing these processes together produces experiences that are rich and fast.
Video from the talk: http://fastly.us/Altitude2015_Design-Performance
Steve's bio: Steve Souders is a co-founder at SpeedCurve, where he develops web performance services. His book, High Performance Web Sites, explains his best practices for performance; it was #1 in Amazon's Computer and Internet bestsellers. His follow-up book, Even Faster Web Sites, provides performance tips for today's Web 2.0 applications. Steve is the creator of many performance tools and services including YSlow, the HTTP Archive, Cuzillion, Jdrop, SpriteMe, ControlJS, and Browserscope. He serves as co-chair of Velocity, the web performance and operations conference from O'Reilly, and is co-founder of the Firebug Working Group.
On the eve of what was hoped to be of the biggest traffic days for New York Magazine’s sites, the company was the target of a DDoS attack that caused their sites to go dark. New York quickly turned to Fastly to deflect and overcome the attack. Larry discusses how New York Mag went from zero page views per second to getting back online and recording one of their biggest traffic days of the year with the aid of Fastly’s team and tech. In addition he discusses how New York is leveraging Fastly as part of a larger strategy of performance improvements to deliver the build a better web and deliver the best premium content experience in the context of alternative distribution and consumption channels, such as Google Amp and FB Instant Article.
The popularity of implementing microservices in today’s application landscape continues to rise, and there have been countless success stories focused on migrating from monoliths to microservices. But as more teams move toward microservices architectures, an increasing number of stories have arisen about the pain of poor choices. Microservices are not the answer to all application problems. Attempts to move away from one giant application to smaller focused services often result in a tightly coupled nest of applications.
Blithe Rocher covers some of the pitfalls and lessons learned from building several service-oriented systems. Blithe explores some of the problems with building, testing, and deploying a functional microservice architecture, from data loss to dependency nightmares, drawing on war stories she has collected and from her own personal experience. You’ll come away with some valuable lessons about microservices without having to go through the pain of experiencing them yourself.
We all want to move fast. We construct our systems in a rapidly-iterating and agile way. Ideally we design and build them to be efficient, robust, and have low latency. But sometimes in the search for speed we make mistakes that come back to haunt us.
The talk is about the things most of us sacrifice when trying to iterate fast. Some of these are reasonable trade-offs — others can wreck your product. I hope you will walk away with a notion of what to pay attention to at various stages of software development, and how you can avoid common pitfalls.
Top 5 Things I've Messed Up in Live StreamingFastly
June 24, 2014 - SF Video Technology Meetup. Live streaming can be difficult and challenging, yet extremely rewarding. In the video gaming world, it has become the most powerful way of reaching your audience. It combines traditional web technologies with even more traditional broadcast video stacks in a "it's going live now" environment. In this presentation Lee Chen, head of product at Fastly, goes over the top 5 things that have lost him sleep, made his eyebrows go up, and sometimes even made him fail -- what he did to correct it.
From list sorting to network routing, and from hash tables to capacity planning, a programmer's daily work is filled with probability. We use probabilistic algorithms, data structures, and systems constantly often without even thinking about it. Experienced engineers reach for probabilistic algorithms frequently and intentionally, especially when building systems of serious scale. How do probabilistic algorithms actually work in practice? And how do we know they'll be safe and reliable in our critical production systems? We'll address those questions, explore a few algorithms, and see why "with high probability" is often better than "exactly".
Racing To Win: Using Race Conditions to Build Correct and Concurrent SoftwareFastly
If you've ever worked on parallel or multiprocessor software, you've almost certainly encountered bugs owning to race conditions between concurrently-executing components. While race conditions intuitively seem bad, it turns out there are cases in which we can use them to our advantage! In this talk, we'll discuss a number of ways that race conditions are used in improving throughput and reducing latency in high-performance systems, without sacrificing correctness along the way.
We'll begin this exploration with a discussion of how various mutual exclusion primitives like locks are implemented efficiently in modern hardware using benign race conditions. From there, we'll investigate how one can implement non-blocking algorithms and concurrent data structures in a correct and deterministic manner using freely-available open source libraries.
The Fallacy of Fast - Ines Sombra at Fastly Altitude 2015Fastly
Fastly Altitude - June 25, 2015. Ines Sombra, a Systems Engineer at Fastly, talks about lessons learned in rapid systems development.
Video of the talk: http://fastly.us/Altitude2015_Fallacy-of-Fast
Ines' bio: Ines Sombra is a Systems Engineer at Fastly, where she spends her time helping the Web go faster. Ines holds an M.S. in Computer Science and an M.S. in Information Management from Washington University in Saint Louis. Being a true Argentine, she has a fondness for steak, fernet, and a pug named Gordo.
Design & Performance - Steve Souders at Fastly Altitude 2015Fastly
Fastly Altitude - June 25, 2015. Chief SpeedCurver Steve Souders explains how design and web performance are more interconnected than ever before. Users want a fast website with a rich design, but sometimes the interplay between design and performance feels like a fixed sum game: one side's gain is the other side's loss. Design and performance are indeed connected, but it's more like the yin and yang. They aren't opposing forces, but instead complement each other. Bringing these processes together produces experiences that are rich and fast.
Video from the talk: http://fastly.us/Altitude2015_Design-Performance
Steve's bio: Steve Souders is a co-founder at SpeedCurve, where he develops web performance services. His book, High Performance Web Sites, explains his best practices for performance; it was #1 in Amazon's Computer and Internet bestsellers. His follow-up book, Even Faster Web Sites, provides performance tips for today's Web 2.0 applications. Steve is the creator of many performance tools and services including YSlow, the HTTP Archive, Cuzillion, Jdrop, SpriteMe, ControlJS, and Browserscope. He serves as co-chair of Velocity, the web performance and operations conference from O'Reilly, and is co-founder of the Firebug Working Group.
On the eve of what was hoped to be of the biggest traffic days for New York Magazine’s sites, the company was the target of a DDoS attack that caused their sites to go dark. New York quickly turned to Fastly to deflect and overcome the attack. Larry discusses how New York Mag went from zero page views per second to getting back online and recording one of their biggest traffic days of the year with the aid of Fastly’s team and tech. In addition he discusses how New York is leveraging Fastly as part of a larger strategy of performance improvements to deliver the build a better web and deliver the best premium content experience in the context of alternative distribution and consumption channels, such as Google Amp and FB Instant Article.
Probabilistic algorithms exist to solve problems that are either impossible or unrealistic (too expensive, too time consuming, etc.) to solve precisely. In an ideal world, you would never actually need to use probabilistic algorithms. For programmers who are not familiar with them, the concept can be positively nerve-racking: “How do I know it will actually work? What if it is inexplicably wrong? How can I debug it? Maybe we should just punt on this problem or buy a whole lot more servers. . .”
However, for those who either deeply understand probability theory or at least have used and observed the behavior of probabilistic algorithms in large-scale production environments, these algorithms are not only acceptable but also worth using at any opportunity. This is because they can help solve problems, create systems that are less expensive and more predictable, and do things that could not be done otherwise.
Advanced VCL Workshop - Rogier Mulhuijzen and Stephen Basile at Fastly Altitu...Fastly
Fastly Altitude - June 25, 2015. Want to integrate Fastly with a paywall, or learn how to efficiently do a large amount of redirects from VCL? This workshop with Fastly engineers Rogier Mulhuijzen and Stephen Basile is a deep dive into six advanced use cases and the VCL needed for them.
Rogier's bio: Rogier “Doc” Mulhuijzen is a Varnish wizard and senior professional services engineer at Fastly where he focuses on performance tuning and troubleshooting. When he’s not helping customers, he sits on the Varnish Governance Board, where he helps give direction and solve issues for the Varnish open source project. Formerly an Oracle DBA and Unix admin, Rogier learned scaling while working for Ziggo, a major Dutch ISP.
We know that design elements play a big part in how a user interacts with a page. But when we apply these same user experience and human-centered design principles to the security warnings in the browser, does it change the user’s behavior? In particular, how can we inform and influence users to make safer decisions when faced with a possible threat?
In this talk, we’ll delve into industry research demonstrating that deliberate UI changes can help people stay safe on the web, and explore ways we can use opinionated design to promote a recommended course of action. We’ll investigate the role of language and imagery, and learn how the principles of choice attractiveness and choice visibility are applied in order to encourage safer browsing behavior.
Over the last few years, Fastly has changed what’s possible at the edge of the internet. But what would it take to build complete, complex applications at the edge? What new tools and concepts would we need and what is the current state-of-the-art? In this talk, Fastly CTO Tyler McMullen discusses where the edge is heading over the next several years, some ideas for what it could look like, and how it could fundamentally change the way you build applications.
Tips for going fast in a slow world: Michael May at OSCON 2015Fastly
Fastly engineer Michael May at OSCON 2015: When it comes to caching, we fall into two categories – those who make phat stacks of cache money and those who suffer from cache anxiety. We know caching aggressively improves performance; however, advanced caching strategies for event-driven content or user-specific content are often neglected for fear of complexity or lack of understanding. In this talk, we’ll cover HTTP caching, old and new strategies for caching historically ‘uncacheable’ content, and secret features of HTTP accelerators like Varnish. Whether you’re already stacking cache or just seeking a prescription for one, you’ll leave with a deeper understanding of caching and accelerating applications that you can take and apply to your Rails, Django, etc. apps.
Beyond Breakpoints: A Tour of Dynamic AnalysisFastly
Despite advances in software design and static analysis techniques, software remains incredibly complicated and difficult to reason about. Understanding highly-concurrent, kernel-level, and intentionally-obfuscated programs are among the problem domains that spawned the field of dynamic program analysis. More than mere debuggers, the challenge of dynamic analysis tools is to be able record, analyze, and replay execution without sacrificing performance. This talk will provide an introduction to the dynamic analysis research space and hopefully inspire you to consider integrating these techniques into your own internal tools.
(Surge 2014) This is a longer version of our Velocity 2014 slides around caching dynamic content. Topic: In the past, CDNs have been used to cache and distribute static objects. But issues around invalidation, staleness, and lack of visibility have prevented us from using CDNs to fully leverage the benefits of caching when it comes to dynamic content. Today, using a real-time, modern CDN that provides instant cache invalidation and real-time analytics allows for instantaneous control over dynamic content caching.
Carmen Sarlo Principal Operations Engineer, Vox Media at Fastly Altitude 2016
Fastly’s API has provided us the ability to create tooling for any member of the team to use and feel confident to roll out changes. Some of our tooling using Fastly’s API is done by chat-ops or integrated workflow through Jenkins. Making edge tasks easier for other team members, makes a happier engineering staff.
Toru Maesaka Software Engineer, Fastly at Altitude 2016
In this talk, Fastly Engineer Toru Maesaka discusses Fastly’s next-generation API authentication and authorization system. The new system introduces an OAuth 2.0 compliant access token, which — unlike our conventional API keys — is issued on a per-user basis. Tokens provide more flexibility by allowing our customers to reflect their organizational requirements to the way the Fastly API is accessed. Toru also walks through other benefits, including limiting API access via token scoping.
Paolo Alvarado Customer Support Engineer, Fastly at Altitude 2016
Customer Support Engineer Paolo Alvarado discusses various useful features of advanced Varnish Configuration Language (VCL).
Eric Kustarz Senior Architect, Fastly
Vicky Nguyen Systems Engineer, Fastly
at Fastly Altitude 2016
How does Fastly make things faster? Systems Engineers Vicky Nguyen and Eric Kustarz discuss how we leverage globally collected data to re-route traffic for specific DNS resolvers.
We looked at lots of collected global data on where a request starts and where it goes. From the user’s device, to a resolver, and finally, to the POP closest to that resolver. What we found is that there are many requests that, because they were being routed to that resolver first, were bypassing a POP that was closer to the device that made the request. Once the DNS request was set, this inefficient HTTP request would be made over and over again.
Vicky and Eric go over how they addressed this issue, speeding up requests by 15-20%.
João tells us "Resource allocation in computer networks is notoriously hard - it took over twenty years to find something that works, and jury is out as to whether we'll ever find something that works properly.
In a rollercoaster ride of historical revisionism, this talk will cover the evolution of resource allocation as applied to networking, and provide context for the mess we're currently in"
[1] Paul Baran - On Distributed Communications - https://www.rand.org/content/dam/rand/pubs/research_memoranda/2006/RM3420.pdf
[2] V. Cerf and R. Kahn - A protocol for packet network intercommunication - https://www.cs.princeton.edu/courses/archive/fall06/cos561/papers/cerf74.pdf
[3] Van Jacobson - Congestion avoidance and control - http://ee.lbl.gov/papers/congavoid.pdf
[4] Bob Briscoe - Flow Rate Fairness: Dismantling a Religion - http://pbg.cs.illinois.edu/courses/cs598fa09/readings/b07.pdf
João's Bio
João Taveira is a network engineer at Fastly, where he is responsible for making dumb switches do clever things. In addition to writing software for network orchestration, Joao works on protocol design and performance, and holds a PhD from University College London on something to that effect.
Load balancing is something most of us assume is a solved problem. But the idea that load balancing is “solved” could not be further from the truth. If you use multiple load balancers, the problem is even worse. Most of us use “random” or “round-robin” techniques, which have certain advantages but are highly inefficient. Others use more complex algorithms like “least-conns,” which can be more efficient but have horrific edge cases. “Consistent hashing” is a very useful technique but only applies to certain problems.
There are several factors that exist both in theory and practice that make efficient load balancing an exceptionally hard problem, including Poisson request arrival times, exponentially distributed response latency, and oscillations when sharing data between multiple load balancers. Luckily, there are techniques and algorithms that have been developed that can make life better. Tyler McMullen explains some of the ways that we can do better than “random,” “round-robin,” and naive “least-conns,” even with distributed load balancers.
Building Customer User Experiences from the EdgeFastly
Delivering custom user experiences for WIRED’s Ad Free product presented a challenge for our current architecture and content management system. By leaning on features exposed by Fastly’s Varnish implementation, WIRED was able to build special site experiences for different users. This is how they solved this problem with the use of edge authentication.
Developing a Globally Distributed Purging SystemFastly
(Surge 2014) How do you build a distributed cache invalidation system that can invalidate content in 150 milliseconds across a global network of servers? Fastly CTO Tyler McMullen and engineer Bruce Spang will discuss the process of constructing a production-ready distributed system built on solid theoretical foundations. This talk will cover using research to design systems, the bimodal multicast algorithm, and the behavior of this system in production.
Mitigating Security Threats with Fastly - Joe Williams at Fastly Altitude 2015Fastly
Fastly Altitude - June 25, 2015. Joe Williams, Computer Operator at GitHub discusses using a CDN to mitigate security threats.
Video of the talk: http://fastly.us/Altitude2015_Mitigating-Security-Threats-2
Joe's bio: Joe Williams is a Computer Operator at GitHub, and joined their infrastructure team in August 2013. Joe's passion for distributed systems, queuing theory and automation help keep the lights on. When not behind a computer you can generally find him riding a bicycle around Marin, CA.
Debugging Your CDN - Austin Spires at Fastly Altitude 2015Fastly
Fastly Altitude - June 25, 2015. Austin Spires, Lead Customer Engineer at Fastly, covers how to use curl tricks, Varnish logging, and web services to identify and debug issues.
Video of the talk: http://fastly.us/Altitude2015_Debugging-Your-CDN
Austin's bio: Austin Spires is a lead customer engineer at Fastly. He’s been working on developer tools and customer happiness for five years, and frequently speaks at conferences and meetups. Recently, he’s been blogging about how Fastly scales its support infrastructure. Before Fastly, Austin worked in sales and support at GitHub, where he helped lead customer onboarding. Originally from Texas, Austin plays a mean bass and likes drinking cheap beer.
An introduction to AWS Elastic Beanstalk, a service to help run your Java web applications on the Amazon cloud, leaving you free to focus on your app. Slides from the London Java Community meetup, 1st June 2011.
Probabilistic algorithms exist to solve problems that are either impossible or unrealistic (too expensive, too time consuming, etc.) to solve precisely. In an ideal world, you would never actually need to use probabilistic algorithms. For programmers who are not familiar with them, the concept can be positively nerve-racking: “How do I know it will actually work? What if it is inexplicably wrong? How can I debug it? Maybe we should just punt on this problem or buy a whole lot more servers. . .”
However, for those who either deeply understand probability theory or at least have used and observed the behavior of probabilistic algorithms in large-scale production environments, these algorithms are not only acceptable but also worth using at any opportunity. This is because they can help solve problems, create systems that are less expensive and more predictable, and do things that could not be done otherwise.
Advanced VCL Workshop - Rogier Mulhuijzen and Stephen Basile at Fastly Altitu...Fastly
Fastly Altitude - June 25, 2015. Want to integrate Fastly with a paywall, or learn how to efficiently do a large amount of redirects from VCL? This workshop with Fastly engineers Rogier Mulhuijzen and Stephen Basile is a deep dive into six advanced use cases and the VCL needed for them.
Rogier's bio: Rogier “Doc” Mulhuijzen is a Varnish wizard and senior professional services engineer at Fastly where he focuses on performance tuning and troubleshooting. When he’s not helping customers, he sits on the Varnish Governance Board, where he helps give direction and solve issues for the Varnish open source project. Formerly an Oracle DBA and Unix admin, Rogier learned scaling while working for Ziggo, a major Dutch ISP.
We know that design elements play a big part in how a user interacts with a page. But when we apply these same user experience and human-centered design principles to the security warnings in the browser, does it change the user’s behavior? In particular, how can we inform and influence users to make safer decisions when faced with a possible threat?
In this talk, we’ll delve into industry research demonstrating that deliberate UI changes can help people stay safe on the web, and explore ways we can use opinionated design to promote a recommended course of action. We’ll investigate the role of language and imagery, and learn how the principles of choice attractiveness and choice visibility are applied in order to encourage safer browsing behavior.
Over the last few years, Fastly has changed what’s possible at the edge of the internet. But what would it take to build complete, complex applications at the edge? What new tools and concepts would we need and what is the current state-of-the-art? In this talk, Fastly CTO Tyler McMullen discusses where the edge is heading over the next several years, some ideas for what it could look like, and how it could fundamentally change the way you build applications.
Tips for going fast in a slow world: Michael May at OSCON 2015Fastly
Fastly engineer Michael May at OSCON 2015: When it comes to caching, we fall into two categories – those who make phat stacks of cache money and those who suffer from cache anxiety. We know caching aggressively improves performance; however, advanced caching strategies for event-driven content or user-specific content are often neglected for fear of complexity or lack of understanding. In this talk, we’ll cover HTTP caching, old and new strategies for caching historically ‘uncacheable’ content, and secret features of HTTP accelerators like Varnish. Whether you’re already stacking cache or just seeking a prescription for one, you’ll leave with a deeper understanding of caching and accelerating applications that you can take and apply to your Rails, Django, etc. apps.
Beyond Breakpoints: A Tour of Dynamic AnalysisFastly
Despite advances in software design and static analysis techniques, software remains incredibly complicated and difficult to reason about. Understanding highly-concurrent, kernel-level, and intentionally-obfuscated programs are among the problem domains that spawned the field of dynamic program analysis. More than mere debuggers, the challenge of dynamic analysis tools is to be able record, analyze, and replay execution without sacrificing performance. This talk will provide an introduction to the dynamic analysis research space and hopefully inspire you to consider integrating these techniques into your own internal tools.
(Surge 2014) This is a longer version of our Velocity 2014 slides around caching dynamic content. Topic: In the past, CDNs have been used to cache and distribute static objects. But issues around invalidation, staleness, and lack of visibility have prevented us from using CDNs to fully leverage the benefits of caching when it comes to dynamic content. Today, using a real-time, modern CDN that provides instant cache invalidation and real-time analytics allows for instantaneous control over dynamic content caching.
Carmen Sarlo Principal Operations Engineer, Vox Media at Fastly Altitude 2016
Fastly’s API has provided us the ability to create tooling for any member of the team to use and feel confident to roll out changes. Some of our tooling using Fastly’s API is done by chat-ops or integrated workflow through Jenkins. Making edge tasks easier for other team members, makes a happier engineering staff.
Toru Maesaka Software Engineer, Fastly at Altitude 2016
In this talk, Fastly Engineer Toru Maesaka discusses Fastly’s next-generation API authentication and authorization system. The new system introduces an OAuth 2.0 compliant access token, which — unlike our conventional API keys — is issued on a per-user basis. Tokens provide more flexibility by allowing our customers to reflect their organizational requirements to the way the Fastly API is accessed. Toru also walks through other benefits, including limiting API access via token scoping.
Paolo Alvarado Customer Support Engineer, Fastly at Altitude 2016
Customer Support Engineer Paolo Alvarado discusses various useful features of advanced Varnish Configuration Language (VCL).
Eric Kustarz Senior Architect, Fastly
Vicky Nguyen Systems Engineer, Fastly
at Fastly Altitude 2016
How does Fastly make things faster? Systems Engineers Vicky Nguyen and Eric Kustarz discuss how we leverage globally collected data to re-route traffic for specific DNS resolvers.
We looked at lots of collected global data on where a request starts and where it goes. From the user’s device, to a resolver, and finally, to the POP closest to that resolver. What we found is that there are many requests that, because they were being routed to that resolver first, were bypassing a POP that was closer to the device that made the request. Once the DNS request was set, this inefficient HTTP request would be made over and over again.
Vicky and Eric go over how they addressed this issue, speeding up requests by 15-20%.
João tells us "Resource allocation in computer networks is notoriously hard - it took over twenty years to find something that works, and jury is out as to whether we'll ever find something that works properly.
In a rollercoaster ride of historical revisionism, this talk will cover the evolution of resource allocation as applied to networking, and provide context for the mess we're currently in"
[1] Paul Baran - On Distributed Communications - https://www.rand.org/content/dam/rand/pubs/research_memoranda/2006/RM3420.pdf
[2] V. Cerf and R. Kahn - A protocol for packet network intercommunication - https://www.cs.princeton.edu/courses/archive/fall06/cos561/papers/cerf74.pdf
[3] Van Jacobson - Congestion avoidance and control - http://ee.lbl.gov/papers/congavoid.pdf
[4] Bob Briscoe - Flow Rate Fairness: Dismantling a Religion - http://pbg.cs.illinois.edu/courses/cs598fa09/readings/b07.pdf
João's Bio
João Taveira is a network engineer at Fastly, where he is responsible for making dumb switches do clever things. In addition to writing software for network orchestration, Joao works on protocol design and performance, and holds a PhD from University College London on something to that effect.
Load balancing is something most of us assume is a solved problem. But the idea that load balancing is “solved” could not be further from the truth. If you use multiple load balancers, the problem is even worse. Most of us use “random” or “round-robin” techniques, which have certain advantages but are highly inefficient. Others use more complex algorithms like “least-conns,” which can be more efficient but have horrific edge cases. “Consistent hashing” is a very useful technique but only applies to certain problems.
There are several factors that exist both in theory and practice that make efficient load balancing an exceptionally hard problem, including Poisson request arrival times, exponentially distributed response latency, and oscillations when sharing data between multiple load balancers. Luckily, there are techniques and algorithms that have been developed that can make life better. Tyler McMullen explains some of the ways that we can do better than “random,” “round-robin,” and naive “least-conns,” even with distributed load balancers.
Building Customer User Experiences from the EdgeFastly
Delivering custom user experiences for WIRED’s Ad Free product presented a challenge for our current architecture and content management system. By leaning on features exposed by Fastly’s Varnish implementation, WIRED was able to build special site experiences for different users. This is how they solved this problem with the use of edge authentication.
Developing a Globally Distributed Purging SystemFastly
(Surge 2014) How do you build a distributed cache invalidation system that can invalidate content in 150 milliseconds across a global network of servers? Fastly CTO Tyler McMullen and engineer Bruce Spang will discuss the process of constructing a production-ready distributed system built on solid theoretical foundations. This talk will cover using research to design systems, the bimodal multicast algorithm, and the behavior of this system in production.
Mitigating Security Threats with Fastly - Joe Williams at Fastly Altitude 2015Fastly
Fastly Altitude - June 25, 2015. Joe Williams, Computer Operator at GitHub discusses using a CDN to mitigate security threats.
Video of the talk: http://fastly.us/Altitude2015_Mitigating-Security-Threats-2
Joe's bio: Joe Williams is a Computer Operator at GitHub, and joined their infrastructure team in August 2013. Joe's passion for distributed systems, queuing theory and automation help keep the lights on. When not behind a computer you can generally find him riding a bicycle around Marin, CA.
Debugging Your CDN - Austin Spires at Fastly Altitude 2015Fastly
Fastly Altitude - June 25, 2015. Austin Spires, Lead Customer Engineer at Fastly, covers how to use curl tricks, Varnish logging, and web services to identify and debug issues.
Video of the talk: http://fastly.us/Altitude2015_Debugging-Your-CDN
Austin's bio: Austin Spires is a lead customer engineer at Fastly. He’s been working on developer tools and customer happiness for five years, and frequently speaks at conferences and meetups. Recently, he’s been blogging about how Fastly scales its support infrastructure. Before Fastly, Austin worked in sales and support at GitHub, where he helped lead customer onboarding. Originally from Texas, Austin plays a mean bass and likes drinking cheap beer.
An introduction to AWS Elastic Beanstalk, a service to help run your Java web applications on the Amazon cloud, leaving you free to focus on your app. Slides from the London Java Community meetup, 1st June 2011.
Continuous Automated Testing - Cast conference workshop august 2014Noah Sussman
CAST 2014 New York: The Art and Science of Testing
The Association for Software Testing www.associationforsoftwaretesting.org
COURSE DESCRIPTION
Automated tools provide test professionals with the capability to make relevant observations even in the fastest-paced environments. Automated testing is also a powerful tool for improving communication between software engineers. This is important because good communication is a prerequisite for growing a great software engineering organization.
This workshop will explore the continuous testing of software systems. Special focus will be given to the situation where the engineering team is deploying code to production so frequently that it is not possible to perform deep regression testing before each release.
People who participate in this course will learn pragmatic automated testing strategies like:
* Data analysis on the command line with find, grep and wc.
* Network analysis with Chrome Inspector, Charles and netcat.
* Using code churn to predict hotspots where bugs may occur.
* Putting stack traces in context with automated SCM blame emails.
* Using statsd to instrument a whole application.
* Testing in production.
* Monitoring-as-testing.
Technical level: participants should have some familiarity with the command line and with editing code using a text editor or IDE. Familiarity with Git, SVN or another version control system is helpful but not required. Likewise some knowledge of Web servers is helpful but not required. It is desirable for participants to bring laptops.
BIO
From 2010 to 2012 Noah was a Test Architect at Etsy. He helped build Etsy's continuous integration system, and has helped countless other engineers develop successful automated testing strategies.These days Noah is an independent consultant in New York. He is passionate about helping engineers understand and use automated tools as they work to scale their applications more effectively.
Autovacuuming is one of the most common causes of stubbed toes for PostgreSQL newbies. This talk will be a deep dive into what vacuuming and autovacuuming do, why they are necessary, how to tune them, and how to evaluate whether or not your tuning is correct. I'll also discuss some lessons learned from doing this in a pathologically bloat-heavy context.
Green Custard Friday Talk 19: Chaos EngineeringGreen Custard
In Green Custard's 19th Friday talk, Zoltan explores the subject of Chaos Engineering
Topics covered:
- What is chaos engineering?
- Why would anyone do this?
- Availability
- Chaos engineering in practice
- The four golden signals
- Chaos engineering in practice
- Chaos Monkey
- The Simian Army
Green Custard is a custom software development consultancy. To discover more about their work and the team visit www.green-custard.com.
This presentation covers the Lean Startup approach to starting a company.
Discover and validate customer segments and what pain they are experiencing – figure out the problem before the solution.
Propose a solution to the problem and validate it with potential customers.
Get feedback from potential customers on a demo or prototype.
If you’re a programmer you make design decisions every second.
Statements, functions, classes, packages, applications, even entire systems: you need to think, and often think hard, about everything. Luckily there are many useful design principles, patterns and best practices that you can apply. But some of them merely expose code smells. Others only help you design your classes. And some are
applicable to packages only. Wouldn’t it be nice to have some more general, always useful, invariably applicable, foundational design principles?
In this talk we’ll look at software from many different perspectives, and while we’re zooming in and out, we’ll discover some of the deeper principles that lie beneath proper object-oriented design. They are the foundation of many of the well-known design patterns and they may even serve as an explanation for code smells.
Moved to https://slidr.io/azzazzel/web-application-performance-tuning-beyond-xmxMilen Dyankov
This slide deck will be removed from here in the future. It has been moved to : https://slidr.io/azzazzel/web-application-performance-tuning-beyond-xmx
How to be Wrong (or How to be Successful at Being Wrong)Russell Miles
In this talk Russ Miles, CEO at ChaosIQ, explores how to turn "Being Wrong" into a super-power through establishing a Resilience Engineering Capability that practices Chaos Engineering.
Erlang - Because s**t Happens by Mahesh Paolini-SubramanyaHakka Labs
Mahesh talks about the buddha-nature of Erlang/OTP, pointing out how the various features of the language tie together into one seamless Fault Tolerant whole. Mahesh emphasizes that Erlang begins and ends with Fault Tolerance. Fault Tolerance is baked into the very genes of Erlang/OTP - something that ends up being amazingly useful when building any kind of system. Mahesh Paolini-Subramanya is the V.P. of R&D at Ubiquiti Networks - a manufacturer of disruptive technology platforms for emerging markets. He has spent the recent past building out Erlang-based massively concurrent Cloud Services and VoIP platforms. Mahesh was previously the CTO of Vocalocity after its merger with Aptela, where he was a founder and CTO.
Given at CraftConf 2015: http://craft-conf.com/2015
Accompanying talk repo: https://github.com/randommood/Craftconf2015
Video: http://www.ustream.tv/recorded/61449003
Let's face it, testing distributed systems is hard. Large number of inputs, partial failures, and asynchrony make these systems seemingly impossible to verify. Formal testing methods are onerous and system correctness continues to elude us. Despite the difficulty, we need to have a way to change our systems with confidence. Integration and unit tests are vital to our sanity and we know it's good for us to use continuous integration to ensure functional consistency across our products.
Come to this talk for a fresh and practical look into the various aspects of distributed systems testing and integration. We will cover CI pipelines: their strengths, weaknesses, and ways to improvement them. Get ready to rediscover the untapped power of your integration practices and develop a burning desire to make them more awesome!
Startupfest 2012 - Coefficients of frictionStartupfest
It must have been amazing to live when the steam engine was invented. For millennia, human enterprise has tried to do one thing: overcome the friction of the physical world. From the first wheel and the earliest lever, to the structure of representative government and the design of broadcast TV, we’ve been fighting friction since we crawled out of the primordial ooze. That steam engine promised spare muscle, a beast of burden than never complained. Machinery would set us free. As it turned out, we were wrong. The answer wasn’t a better way to overcome friction—it was a move to the near-frictionless world of electrons. Today, every edifice we’ve erected to fight friction is crumbling in the face of a frictionless future. Join Alistair Croll for a wild romp through the economics of abundance, augmented humanity, home manufacturing, firing before aiming, coal supplies, education, and more, and see why there is simply no better time in human history to be a disruptor.
Jogging While Driving, and Other Software Engineering Research Problems (invi...David Rosenblum
invited talk presented for the Distinguished Lecturer Series of the Department of Computer Science at the University of Illinois at Chicago, 10 April 2014
Using Apache ACE as a distribution and management platform for a large--and growing-- number of embedded devices in the field.
I used this presentation at Apachecon NA 2010.
I'm more about story and images than about text on slides, you can try to follow along here.
Throughout my career in science, engineering and management I attended numerous meeting where many misconceptions and misinterpretations were evident. Perhaps the most expansive and expensive were the probabilities assumed and calculated for system reliability and/or product manufacturing quality. Eventually, I began to refer to this as ‘five nines’ problem!
Not fully understanding the origins of the reliability measures, it is so easy to demand a 99.999% instead of 99.99% up time for an electronic system. What could be easier? At face value it appears to be trivial and straightforward! Likewise, taking a 5s manufacturing plant up to a 6s defect level turns out to be a monumental engineering challenge! And at the time of writing 6s has never been achieved!
It appears that to few engineering and management courses address this topic, and if they do, it is as a scant reference of insufficient depth. So, we see far too many students understand in any depth, if at all! And when they become managers they just ‘don’t get it’!
This presentation and the associated lecture have been specifically created to address this problem with relevance to BSc, BA, MSc and MBA students along with anyone needing a refresher or explicit introduction to the topic. In addition to the graphics, animations and movies, the lecture is also littered with practical examples and the outcomes of case studies.
RFC 7540 was ratified over 2 years ago and, today, all major browsers, servers, and CDNs support the next generation of HTTP. Just over a year ago, at Velocity, we discussed the protocol, looked at some real world implications of its deployment and use, and what realistic expectations we should have from its use. Now that adoption is ramped up and the protocol is being regularly used on the Internet, it's a good time to revisit the protocol and its deployment. Has it evolved? Have we learned anything? Are all the features providing the benefits we were expecting? What's next?In this session, we'll review protocol basics and try to answer some of these questions based on real-world use of it. We'll dig into the core features like interaction with TCP, server push, priorities and dependencies, and HPACK. We'll look at these features through the lens of experience and see if good practice patterns have emerged. We'll also review available tools and discuss what protocol enhancements are in the near and not-so-near horizon.
Altitude San Francisco 2018: Preparing for Video Streaming Events at ScaleFastly
CBS Interactive streams some of the largest video streaming events on the planet, including SuperBowl in 2019. This talk will focus on all the work that goes in ahead of time to prepare and plan for game day. From architecture design to capacity reservations to operational visibility and building playbooks we will explore how we build, test and prepare for these large events. We will also explore how some of Fastly's unique features such as MediaShield and VCL are becoming critical to these workflows.
Altitude San Francisco 2018: Building the Souther Hemisphere of the InternetFastly
As a global organization, Fastly carefully selects and deploys POP locations to service the greater audience of the Internet. Fastly currently has 52 global POPs across the Internet, 13 of which are located in the Southern Hemisphere. Another 3 are outside North America, Europe, and Asia. During this talk, VP of Infrastructure Tom Daly will share our experience in building Fastly's network of POPs south of the equator, where, in some cases, the Internet we know here in San Francisco, is much different. Tom will explore the physical datacenter infrastructure, network topology, and network policy that pose of unique challenges when operating in these parts of the world.
Altitude San Francisco 2018: The World Cup StreamFastly
FuboTV’s recent offering of the 2018 FIFA World Cup broke all of our previous records for viewership and put our systems to the test as we delivered all 64 matches live. Coverage for a majority of games was spread out across ~150 regional sports networks, local FOX affiliates, owned and operated regional stations and other local FOX offerings, with a few early matches broadcasted on national channels. Running a successful World Cup required us to pay close attention to our caching strategies, delivery mechanisms, content edge-case handling and more. An event at this scale, spread out over a month, also gave us an excellent test bed to run experiments. We were able to augment our last-mile delivery, test/tweak our solution for CDN decisioning/priority, and even stand up a set of UHD HDR10 feeds to give our users their first glimpse of live OTT UHD offerings. We’ll run through this whole event from a scale and technology perspective and share our takeaways as we prepare for the upcoming NFL season and beyond.
Altitude San Francisco 2018: Scale and Stability at the Edge with 1.4 Billion...Fastly
Braze is a customer engagement platform that delivers more than a billion messaging experiences across push, email, apps and more each day. In this session, Jon Hyman will describe the company's challenges during an inflection point in 2015 when the company reached the limitation of their physical networking equipment, and how Braze has since grown more than 7x on Fastly. Jon will also discuss how Braze uses Fastly's Layer 7 load balancing to improve stability and uptime of its APIs.
Altitude San Francisco 2018: Moving Off the Monolith: A Seamless MigrationFastly
In this talk, Jeff Valeo from Grubhub will talk about how they leveraged Fastly to slowly migrate user traffic from a legacy monolith to a new, service-based architecture. This solution allowed Grubhub to shift millions of users as new functionality was built with zero downtime.
Altitude San Francisco 2018: Bringing TLS to GitHub PagesFastly
Sam Kottler, SRE Engineering Manager at GitHub will dig into how they rearchitected Pages, so that custom domains now support HTTPS, meaning over a million GitHub Pages sites will be served over HTTPS.
Altitude San Francisco 2018: HTTP Invalidation WorkshopFastly
One of the most powerful tools that Fastly offers is worldwide, instant purge. Come learn the ins and outs of how HTTP invalidation works in general and how purge and surrogate keys can be used to improve your site's delivery and get even more value from Fastly.
This talk will also cover the purge blast radius
Surrogate Keys are an amazing way to purge your content from cache, but they can be a bit scary when you aren't sure how many URLs this surrogate key is tied to or what kind of affect this will have on origin. Join the USA Today Network as we explain how we leverage big data tools, Go APIs, New Relic, and Sumo Logic to provide our users a suite of tools for purging content from Fastly. Developers love knowing the blast radius of their surrogate keys, while our engineers love the real-time metrics and notifications we get when developers are hard-purging content.
Altitude San Francisco 2018: How Magento moved to the cloud while maintaining...Fastly
Magento Commerce was first released by a small web development agency over ten years when they saw first-hand what a challenge it was for companies like them to build unique eCommerce sites. They created an open source platform that gives developers the flexibility to create meaningful shopping experiences while building a global community that drives down merchant costs and fosters innovation. Amid the rise of cloud-based software Magento needed to keep pace with more complex merchant needs and heightened shopper expectations. In this session learn how Magento, with the help of Partners like Fastly, evolved into a cloud-based platform without sacrificing their commitment to open software, flexibility, and the community.
Altitude San Francisco 2018: Scaling Ethereum to 10B requests per dayFastly
ConsenSys is a venture production studio building decentralized applications and developer and end-user tools for blockchains. Their Infura platform is a core infrastructure pillar of Ethereum, enabling decentralized applications of all kinds to scale to accommodate their users.
Infura went from 20 million requests a day at the beginning of 2017 to over 10 billion requests today. This staggering 500x increase naturally lead to questions of scale.
In this talk, co-founder Michael Wuehler will discuss the technical challenges encountered while building and scaling the Infura platform, and the infrastructure decisions that led to their adoption of Fastly and other pivotal technologies.
Altitude San Francisco 2018: Authentication at the EdgeFastly
Turning away unwanted traffic close to the source is a common and key use case for edge networks like Fastly, but identity, authentication, and authorization at the edge can go far beyond blocking DDoS. The unique way that you identify your site’s users can probably move to the edge too, allowing you to cut response times in your critical path, offload more origin traffic, and make smarter routing decisions at the edge.
In this talk we’ll cover a number of patterns in use by real Fastly customers. Whether you prefer token authentication, pre-shared keys, OAuth, HTTP auth, JSON web tokens, or a complex paywall, learn how you can potentially make your authentication decisions at the edge.
Altitude San Francisco 2018: Testing with Fastly WorkshopFastly
A crucial step for continuous integration and continuous delivery with Fastly is testing the service configuration to provide confidence in changes. This workshop will cover unit-testing VCL, component testing a service as a black box, systems testing a service end-to-end and stakeholder acceptance testing.
Altitude San Francisco 2018: Fastly Purge Control at the USA TODAY NETWORKFastly
One of the most powerful tools that Fastly offers is worldwide, instant purge. Come learn the ins and outs of how HTTP invalidation works in general and how purge and surrogate keys can be used to improve your site's delivery and get even more value from Fastly.
This talk will also cover the purge blast radius
Surrogate Keys are an amazing way to purge your content from cache, but they can be a bit scary when you aren't sure how many URLs this surrogate key is tied to or what kind of affect this will have on origin. Join the USA Today Network as we explain how we leverage big data tools, Go APIs, New Relic, and Sumo Logic to provide our users a suite of tools for purging content from Fastly. Developers love knowing the blast radius of their surrogate keys, while our engineers love the real-time metrics and notifications we get when developers are hard-purging content.
In this hands-on workshop you will attack a vulnerable web application while defending your own web service behind a Fastly WAF. Attendees will depart understanding how common web application attacks can be exploited as well defended against. They will experience WAF logging and analytics via sumologic to detect attacks realtime. For mitigation you will use a preview version of our newly built WAF rule management UI. We will close off the workshop by deep diving on how our security team analyzed and mitigated some of this summer major vulnerabilities.
Altitude San Francisco 2018: Logging at the Edge Fastly
Fastly delivers more than a million log events per second. Our Real-Time Log Streaming is easy to set up, but there are many features you might not be using to their full extent.
This workshop will cover setting up logging to various endpoints, dealing with structured data, and getting real-time insights into your customers’ behavior.
Altitude San Francisco 2018: Video Workshop DocsFastly
Fastly delivers more than a million log events per second. Our Real-Time Log Streaming is easy to set up, but there are many features you might not be using to their full extent.
This workshop will cover setting up logging to various endpoints, dealing with structured data, and getting real-time insights into your customers’ behavior.
- - - - - - - - - - -
Live streaming and on-demand video can provide a powerful way to connect with customers, but viewers expect seamless pixel-perfect streams without common video delivery inconveniences, such as downtime or lags. This workshop will demonstrate how anyone can deliver live video at scale. We’ll thoroughly explain key video delivery optimizations and more importantly, demonstrate their efficacy using the data collected from both Fastly Log Streaming/Sumo Logic and the Mux quality of experience service.
Altitude San Francisco 2018: Programming the EdgeFastly
Programming the edge
Second floor
Andrew Betts
Principal Developer Advocate, Fastly
Hide abstract
Through our support for running your own code on our edge servers, Fastly's network offers you a platform of unparalleled speed, reliability and efficiency to which you can delegate a surprising amount of logic that has traditionally been in the application layer. In this workshop, you'll implement a series of advanced edge solutions, and learn how to apply these patterns to your own applications to reduce your origin load, dramatically improve performance, and make your applications more secure.
Securing your Kubernetes cluster_ a step-by-step guide to success !KatiaHIMEUR1
Today, after several years of existence, an extremely active community and an ultra-dynamic ecosystem, Kubernetes has established itself as the de facto standard in container orchestration. Thanks to a wide range of managed services, it has never been so easy to set up a ready-to-use Kubernetes cluster.
However, this ease of use means that the subject of security in Kubernetes is often left for later, or even neglected. This exposes companies to significant risks.
In this talk, I'll show you step-by-step how to secure your Kubernetes cluster for greater peace of mind and reliability.
Elevating Tactical DDD Patterns Through Object CalisthenicsDorra BARTAGUIZ
After immersing yourself in the blue book and its red counterpart, attending DDD-focused conferences, and applying tactical patterns, you're left with a crucial question: How do I ensure my design is effective? Tactical patterns within Domain-Driven Design (DDD) serve as guiding principles for creating clear and manageable domain models. However, achieving success with these patterns requires additional guidance. Interestingly, we've observed that a set of constraints initially designed for training purposes remarkably aligns with effective pattern implementation, offering a more ‘mechanical’ approach. Let's explore together how Object Calisthenics can elevate the design of your tactical DDD patterns, offering concrete help for those venturing into DDD for the first time!
GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using Deplo...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
Connector Corner: Automate dynamic content and events by pushing a buttonDianaGray10
Here is something new! In our next Connector Corner webinar, we will demonstrate how you can use a single workflow to:
Create a campaign using Mailchimp with merge tags/fields
Send an interactive Slack channel message (using buttons)
Have the message received by managers and peers along with a test email for review
But there’s more:
In a second workflow supporting the same use case, you’ll see:
Your campaign sent to target colleagues for approval
If the “Approve” button is clicked, a Jira/Zendesk ticket is created for the marketing design team
But—if the “Reject” button is pushed, colleagues will be alerted via Slack message
Join us to learn more about this new, human-in-the-loop capability, brought to you by Integration Service connectors.
And...
Speakers:
Akshay Agnihotri, Product Manager
Charlie Greenberg, Host
Smart TV Buyer Insights Survey 2024 by 91mobiles.pdf91mobiles
91mobiles recently conducted a Smart TV Buyer Insights Survey in which we asked over 3,000 respondents about the TV they own, aspects they look at on a new TV, and their TV buying preferences.
Software Delivery At the Speed of AI: Inflectra Invests In AI-Powered QualityInflectra
In this insightful webinar, Inflectra explores how artificial intelligence (AI) is transforming software development and testing. Discover how AI-powered tools are revolutionizing every stage of the software development lifecycle (SDLC), from design and prototyping to testing, deployment, and monitoring.
Learn about:
• The Future of Testing: How AI is shifting testing towards verification, analysis, and higher-level skills, while reducing repetitive tasks.
• Test Automation: How AI-powered test case generation, optimization, and self-healing tests are making testing more efficient and effective.
• Visual Testing: Explore the emerging capabilities of AI in visual testing and how it's set to revolutionize UI verification.
• Inflectra's AI Solutions: See demonstrations of Inflectra's cutting-edge AI tools like the ChatGPT plugin and Azure Open AI platform, designed to streamline your testing process.
Whether you're a developer, tester, or QA professional, this webinar will give you valuable insights into how AI is shaping the future of software delivery.
Dev Dives: Train smarter, not harder – active learning and UiPath LLMs for do...UiPathCommunity
💥 Speed, accuracy, and scaling – discover the superpowers of GenAI in action with UiPath Document Understanding and Communications Mining™:
See how to accelerate model training and optimize model performance with active learning
Learn about the latest enhancements to out-of-the-box document processing – with little to no training required
Get an exclusive demo of the new family of UiPath LLMs – GenAI models specialized for processing different types of documents and messages
This is a hands-on session specifically designed for automation developers and AI enthusiasts seeking to enhance their knowledge in leveraging the latest intelligent document processing capabilities offered by UiPath.
Speakers:
👨🏫 Andras Palfi, Senior Product Manager, UiPath
👩🏫 Lenka Dulovicova, Product Program Manager, UiPath
JMeter webinar - integration with InfluxDB and GrafanaRTTS
Watch this recorded webinar about real-time monitoring of application performance. See how to integrate Apache JMeter, the open-source leader in performance testing, with InfluxDB, the open-source time-series database, and Grafana, the open-source analytics and visualization application.
In this webinar, we will review the benefits of leveraging InfluxDB and Grafana when executing load tests and demonstrate how these tools are used to visualize performance metrics.
Length: 30 minutes
Session Overview
-------------------------------------------
During this webinar, we will cover the following topics while demonstrating the integrations of JMeter, InfluxDB and Grafana:
- What out-of-the-box solutions are available for real-time monitoring JMeter tests?
- What are the benefits of integrating InfluxDB and Grafana into the load testing stack?
- Which features are provided by Grafana?
- Demonstration of InfluxDB and Grafana using a practice web application
To view the webinar recording, go to:
https://www.rttsweb.com/jmeter-integration-webinar
12. Design for change
Embrace modularity & information hiding
Stress clarity & documentation
Amputate disease-ridden parts
Plan for eventual replacement
Preventative medicine
16. The problem with state
Restarting a database clears its memory
Reading 120GB of data from disk takes
about 3 hours per server (8 per machine)
Even with orchestrated restarts & partial
queries total of ~12 hours to restart a fleet
Operationally
expensive & slow!
#
17. “When we shutdown a server
for a planned upgrade, we
know that the memory state
is good… so we decided to
decouple the memory’s
lifetime from the process’s
lifetime“
24. Common wisdom
Effective scaling is
evidence of solid
system building
Why does this happen?
McSherry et al.
Any system can scale
arbitrarily well with a
sufficient lack of care
in its implementation
38. Yield as response ruggedness
Close to uptime (% requests answered
successfully) but more useful because it
directly maps to user experience
Failure during high & low traffic generates
different yields. Uptime misses this
Focus on yield rather than uptime
39. Harvest as quality of response
From Coda Hale’s “You can’t sacrifice partition tolerance”
Server A Server B Server C
Baby AnimalsCute
40. Harvest as quality of response
From Coda Hale’s “You can’t sacrifice partition tolerance”
Server A Server B Server C
Baby AnimalsCute
X
66% harvest
41. #1: Probabilistic Availability
Graceful harvest degradation under faults
Randomness to make the worst-case &
average-case the same
Replication of high-priority data for greater
harvest control
Degrading results based on client capability
42. #2 Decomposition & Orthogonality
Decomposing into subsystems independently
intolerant to harvest degradation (fail by
reducing yield). But app can continue if they fail
Only provide strong consistency for the
subsystems that need it
Orthogonal mechanisms (state vs functionality)
%
44. Ruggedness via verification
Formal
Methods Testing
TOP-DOWN
FAULT INJECTORS, INPUT GENERATORS
BOTTOM-UP
LINEAGE DRIVEN FAULT INJECTORS
WHITE / BLACK BOX
WE KNOW (OR NOT) ABOUT THE SYSTEM
HUMAN ASSISTED PROOFS
SAFETY CRITICAL (TLA+, COQ, ISABELLE)
MODEL CHECKING
PROPERTIES + TRANSITIONS (SPIN, TLA+)
LIGHTWEIGHT FM
BEST OF BOTH WORLDS (ALLOY, SAT)
&
46. Ruggedness with MOLLY
“Without explicitly
forcing a system to
fail, you have no
confidence that it
will operate
correctly in failure
modes”Caitie McCaffrey’s pearls of wisdom
'(
Verifier
Programmer
48. “Presents a middle ground
between pragmatism and
formalism, dictated by the
importance of verifying fault
tolerance in spite of the
complexity of the space of
faults”
50. Agile Lean Rugged
tl;dr - foundations
A scalable
system may
not be a lean
system
Pursuing
scalability out
of context can
be COSTly
Designing for
change is
designing for
success
Think about
availability in
terms of yield
and harvest
Graceful
degradation is a
design outcome
! !
51. Agile Lean Rugged
tl;dr - Frontiers
Asking the
wrong question
is wasteful
Think about
what is truly
needed
Use
approximations
State can be
challenging
Saving state in
shared
memory allows
us to restart
DB processes
faster
Reasoning
backwards from
correct system
output helps us
determine the
execution
failures that
prevent it from
happening
52. Join your local PWL and
read The Morning Paper!
github.com/Randommood/GotoLondon2015
Papers are a lot of fun!)