Beyond Breakpoints: A Tour of Dynamic Analysis

Learn from Fastly veteran Cassandra Dixon on some of the most common customer issues we see — such as why things aren’t caching, misconfigured origins, issues with intermediary proxies, and VCL snafus — and the best ways to resolve them. We’ll also discuss our unique approach to debugging — using seemingly mundane tools to diagnose issues in creative ways — and how you can apply these methods to your own organization to get the most out of Fastly’s offerings.

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.

Pushing symfony events in real time to your clients This talk, held at the symfony live Paris unconference, gives an overview about how events thrown in symfony can be dispatched in real time to web clients. It describes the architecture of the solution and provides examples using the open source comet server APE

This document provides a complete guide to Node.js, covering installation methods, checking installation, modules, NPM, events, streams, and persisting data. It discusses installing Node.js from nodejs.org, using a version manager like NVM, or compiling from source. It also covers creating a basic web server, reading and writing files, uploading files, and using Socket.IO for real-time applications.

Node.js is a JavaScript runtime built on Chrome's V8 engine that allows building scalable network applications using JavaScript on the server-side. It uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, suitable for data-intensive real-time applications that run across distributed devices. Common uses of Node.js include building web servers, file upload clients, ad servers, chat servers, and any real-time data applications. The document provides an introduction to Node.js concepts like callbacks, blocking vs non-blocking code, the event loop, streams, events, and modules.

This document discusses asynchronous I/O in Java and Scala using the Play Framework. It describes how LinkedIn uses a service-oriented architecture with hundreds of services making requests to each other. It then covers how Play supports non-blocking I/O using asynchronous code, promises, and futures to allow parallel requests without blocking threads. Key points covered include using map and flatMap to transform promises and futures, handling errors and timeouts, and the benefits of non-blocking I/O for scalability.

A WebSockets HOW-TO using Scala and Play!Framework. Links to example repositories and other resources. Created for the AmsterdamScala meetup.

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.

1. Shielding and clustering help improve performance by distributing requests across multiple POPs and collapsing duplicate requests. 2. Shielding offloads requests to "shield" POPs to avoid bottlenecks and beat the speed of light, while clustering collapses requests within each POP. 3. Implementing shielding and clustering in VCL requires care to avoid issues like requests being processed differently on edge and shield POPs.

Pam Selle Co-author of Choosing a JavaScript Framework, thewebivore.com Tuesday, Oct 20th 4:20 pm - Design/UX/UI

You know how HTTP caching works but need more? In this talk we look into ways to cache personalized content. We will look at Edge Side Includes (ESI) to tailor caching rules of fragments, and at the user context concept to differentiate caches not by individual user but by permission groups.

Given at YAPC::EU 2012 Dancer + WebSocket + AnyEvent + Twiggy This in *not* a talk about doing a hello world in Dancer, as there are plenty of it. This is a real-life example of using Dancer to address a problem in an elegant and powerful way At $job, we have cpan mirrors. We want them to stay a bit behind the real CPAN for stability, but we have a tool to update modules from the real CPAN to our mirrors. Cool. I wanted to have a web interface to trigger it, and monitor the injection. This problem is not a typical one (blog, wiki, CRUD, etc). Here we have a long running operation that shall happen only one at a time, that generates logs to be displayed, with states that need keeping. In this regard, it's interesting to see how Dancer is versatile enough to address these situations with ease. This talk details how I did that, the technology I used, and the full source code (which is quite short). I used Dancer + WebSocket + AnyEvent + Twiggy + some other stuff. This talk doesn't require any particular knowledge beyond basic Perl, and very basic web server understanding.

Reverse Ajax, also known as Comet, allows a server to push data to a client without the client explicitly requesting it. This is achieved through techniques like long polling where the client opens a persistent connection to the server to receive messages as they happen. Common libraries that implement Reverse Ajax include CometD, Atmosphere, and DWR, with CometD being a preferred option as it supports websockets and offers full client/server functionality.

This presentation is part 5 in the EWD 3 Training Course. It describes the first steps you should take when building a browser-based desktop QEWD application. This version of Part 5 is for anyone using QEWD on Linux or a Raspberry Pi.

Service workers allow you to control how network requests from web pages are handled. They run scripts in the background to intercept and handle fetch events, allowing web applications to work offline by responding with cached responses. Before service workers, AppCache was used but had limitations. The lifecycle of a service worker involves registration, installation, activation, and controlling pages. Common uses are caching assets, providing offline functionality, and handling network responses. Challenges include debugging failed installations and limitations on credentials and CORS requests. Service workers also enable push notifications and background sync functionality.

The document discusses connecting Android applications to web services using HTTP, XML, JSON, and OAuth. It covers using the HttpClient API to make HTTP requests, parsing responses in XML and JSON formats, and obtaining access tokens from services using OAuth authentication. The document also recommends libraries for tasks like XML/JSON processing and provides examples of client libraries that connect to specific web services.

This is part 38 of the EWD 3 Training Course. This presentation begins to explore in detail how to develop a React.js application that integrates with QEWD

This document discusses applying Varnish, including topics like the VCL (Varnish Configuration Language), request flow, sticky origins, localized site redirects, token authentication, and third party authentication. It concludes by inviting any questions from the audience.

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.

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.

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.

CDNs provide caching and delivery of web content but are often misused. CDNs can cache more dynamic content than typically done and improve performance. Precise measurement is still difficult, such as determining cache hit rates and impacts of memory versus disk hits. Overall, CDNs have more potential for optimization and caching improvements remain an ongoing challenge.

This document discusses refactoring techniques for Ember applications. It describes using tests to guide refactoring, including custom test helpers for things like finding elements. An example shows refactoring a service for making requests by version into a more generic resource service. The recap encourages relying on tests, writing targeted helpers, addressing code smells, adding features, applying the "three times rule" of repetition, and refactoring during upgrades.

Fastly Altitude - June 25, 2015. Catchpoint CEO Mehdi Daoudi talks about performance measuring and monitoring. Video from the talk: http://fastly.us/Altitude2015-Catchpoint-Video Mehdi's bio: Mehdi is the founder and CEO of Catchpoint, the fastest-growing Web Performance Monitoring Solution. The Catchpoint vision is to provide the best IT analytics & intelligence to help companies improve their end user performance and keep an eye on their infrastructure and vendors. Before Catchpoint, Mehdi spent 10+ years at DoubleClick and Google, where he was responsible for Quality of Services, buying, building, deploying and using various internal and external monitoring solutions to keep an eye on the DART infrastructure delivering billions of transactions a day using thousands of servers, routers, and various other web performance systems.

The document discusses probabilistic algorithms and their use for solving count-distinct problems. It explains that probabilistic algorithms provide probabilistically bounded error rates rather than exact answers. The count-distinct problem aims to estimate the number of unique elements in a large dataset and is used in applications like estimating unique website visitors. The document presents the LogLog algorithm as a probabilistic solution that partitions data and tracks the maximum number of leading zeros seen to estimate the count in a memory-efficient way.

The physical, logical, and economic topology of the Internet is ever changing due to new network to network interconnections, the planned or accidental disconnection of existing interconnections, and the ever growing needs for more network capacity. As a multi-Terabit traffic source, Fastly must regularly evaluate its needs for network capacity against performance and operating costs. This talk will examine the capacity planning models, scalability concerns, and economic drivers used to make key business decisions regarding connectivity, emphasizing the needs for metrics collection, analysis, and constant iterative tuning involving a distributed, international team.

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

The document discusses common mistakes made when prioritizing speed over quality, such as de-emphasizing testing, releases, operations, insights, security, and knowledge. It recommends focusing on system design, configurations, limits, growth, processes, resources, and building resilience through redundancies and documentation. Testing the full system, having playbooks, and minding assumptions and dependencies are emphasized.

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.

This document discusses caching strategies for Rails applications, including: 1. Using Rails caching for queries, pages, assets, and fragments to improve performance. 2. Configuring Cache-Control headers, compression, and CDNs like Fastly for efficient caching. 3. Techniques for caching dynamic content at the edge using surrogate keys and purging cached responses.

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 internet and how people interact with content online has evolved, with event-driven and personalized experiences becoming more common. Content delivery networks (CDNs) are struggling to meet new demands. While edge computing addresses some issues, true personalization and interactivity require data as well. For the next phase of the internet, data must also move to the edge to power personalized, real-time experiences globally. However, distributing and keeping data consistent across all edge locations presents significant technical challenges.

This document discusses how Target deployed Fastly in front of its existing infrastructure to speed up response times and give engineers control over caching without any downtime or production issues. It outlines the reasoning for using Fastly, including lightening the load on data centers and gaining control over caching and purging. It then details the plan, struggles, migration process, benefits, and future plans for using Fastly.

From Zero to Capacity Planning is a journey of discovery about capacity planning. Key learnings include defining your system's architecture and metrics, using historical data to predict future capacity needs, and ensuring capacity expansions don't disrupt service. While challenging, capacity planning is important for understanding constraints and proactively managing system growth. Both capacity and optimizations must be addressed through formal planning and an organized team effort.

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.

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.

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.

We all make mistakes while programming and spend a lot of time fixing them. One of the methods which allows for quick detection of defects is source code static analysis.

We all make mistakes while programming and spend a lot of time fixing them. One of the methods which allows for quick detection of defects is source code static analysis.

Video and slides synchronized, mp3 and slide download available at URL http://bit.ly/2dXUUTG. Nathan Taylor provides an introduction to the dynamic analysis research space, suggesting integrating these techniques into various internal tools. Filmed at qconnewyork.com. Nathan Taylor is a software developer currently employed at Fastly, where he works on making the Web faster through high performance content delivery. Previous gigs have included hacking on low-level systems software such as Java runtimes at Twitter and, prior to that, the Xen virtual machine monitor in grad school.

This document discusses Skiron, an experimental CPU design project implemented in the D programming language. It provides an overview of Skiron, which simulates a RISC-inspired instruction set architecture. It describes the idioms and patterns used in D to define the instruction set and encoding in a way that is self-documenting and allows different parts of the software to stay in sync. It also discusses lessons learned, such as issues with delegates, as well as potential improvements to D's metaprogramming capabilities and standard library support for @nogc code. Realizing Skiron in hardware with an FPGA and making it self-hosting are presented as future goals.

The document provides an overview of the C programming language. It states that C was developed in 1972 by Dennis Ritchie at Bell Labs and was used to develop the UNIX operating system. The document then covers various features of C like it being a mid-level programming language, having structured programming, pointers, loops, functions, arrays, and more. It provides examples to explain concepts like input/output functions, data types, operators, control structures, and pointers.

This document discusses building a virtual platform for the OpenRISC architecture using SystemC and transaction-level modeling. It covers setting up the toolchain, writing test programs, and simulating the platform using event-driven or cycle-accurate simulation with Icarus Verilog or the Vorpsoc simulator. The virtual platform allows fast development and debugging of OpenRISC code without requiring physical hardware.

PVS-Studio is a static analyzer that detects errors in source code of C, C++, C++11, C++/CX applications.

Charlie Miller and Vincenzo Iozzo presented techniques for post-exploitation on the iPhone 2 including: 1. Running arbitrary shellcode by overwriting memory protections and calling vm_protect to mark pages as read/write/executable. 2. Loading an unsigned dynamic library called Meterpreter by mapping it over an existing signed library, patching dyld to ignore code signing, and forcing unloaded of linked libraries. 3. Adding new functionality to Meterpreter, such as a module to vibrate and play a sound on the iPhone, demonstrating how payloads can be extended once loaded into memory.

This document discusses common gateway interface (CGI) programming and server-side programming. It provides examples of CGI programs written in C to multiply two numbers submitted through an HTML form using GET and POST methods. It discusses how CGI works, including getting environment variables and user input. Some disadvantages of CGI include spawning new processes for each request and security issues. It suggests using server-side scripting languages like PHP for more efficient and secure server-side programming.

1) ISPC (Intel SPMD Program Compiler) is a language that extends C with "single program, multiple data" constructs to enable easy vectorization of code. It describes the behavior of a single program instance while executing a "gang" of instances in parallel. 2) ISPC was shown to provide significant speedups (up to 5x) over non-vectorized C/C++ code for problems like matrix multiplication and Kalman filtering. 3) While OpenCL can also enable vectorization, ISPC offers advantages like explicit control over vectorized vs serial code, performance warnings, and easier composition with task schedulers than OpenCL.

Here is a bpftrace program to measure scheduler latency for ICMP echo requests: #!/usr/local/bin/bpftrace kprobe:icmp_send { @start[tid] = nsecs; } kprobe:__netif_receive_skb_core { @diff[tid] = hist(nsecs - @start[tid]); delete(@start[tid]); } END { print(@diff); clear(@diff); } This traces the time between the icmp_send kernel function (when the packet is queued for transmit) and the __netif_receive_skb_core function (when the response packet is received). The

PVS-Studio is a static code analyzer designed for developers of state-of-the-art resource-intensive applications.

An exploration into RxJava on Android for the experienced, yet uninitiated software engineer. This presentation explores Declarative vs Imperative programming paradigms and expands the discussion into Functional Reactive Programming. It explains the benefits of the observer contract, high-order functions, and schedulers available in RxJava. It also explains the purpose of the Android integration libraries: RxAndroid, RxLifecycle, and RxBindings.

The Linux 4.x series introduced a new powerful engine of programmable tracing (BPF) that allows to actually look inside the kernel at runtime. This talk will show you how to exploit this engine in order to debug problems or identify performance bottlenecks in a complex environment like a cloud. This talk will cover the latest Linux superpowers that allow to see what is happening “under the hood” of the Linux kernel at runtime. I will explain how to exploit these “superpowers” to measure and trace complex events at runtime in a cloud environment. For example, we will see how we can measure latency distribution of filesystem I/O, details of storage device operations, like individual block I/O request timeouts, or TCP buffer allocations, investigating stack traces of certain events, identify memory leaks, performance bottlenecks and a whole lot more.

A detailed overview of Kapacitor, InfluxDB’s native data processing engine. How to install, configure and build custom TICKscripts enable alerting and anomaly detection

This document discusses compiler optimizations. It begins with an outline of topics including compilation trajectory, intermediate languages, optimization levels, and optimization techniques. It then provides more details on each phase of compilation, how compilers use intermediate representations to perform optimizations, and specific optimizations like common subexpression elimination, constant propagation, and instruction scheduling.

This document discusses embedded system development. It begins with definitions of embedded systems and some of their common characteristics like limited resources and real-time constraints. It then discusses specific issues like memory alignment, flash and RAM sizes, and performance optimizations. Examples are given of embedded projects like digital video recorders and how to address issues like file sorting, memory usage and stack overflows. The conclusion emphasizes that embedded systems involve knowledge from many technical fields and stresses the importance of experience, observation, and a positive problem-solving attitude.

PascalScript is a scripting engine that allows scripts written in Object Pascal to be executed at runtime in Delphi and Free Pascal applications. It provides advantages like allowing customization without recompiling and updating applications by distributing new script files. The engine works by compiling scripts to bytecode using a compiler component, and executing the bytecode using an executer component. It supports common data types, functions, classes, and calling external libraries.

In this talk, Gil Yankovitch discusses the PaX patch for the Linux kernel, focusing on memory manager changes and security mechanisms for memory allocations, reads, writes from user/kernel space and ASLR.

This document summarizes Andy Wingo's talk at JSConf 2012 about his work on the JavaScriptCore engine. It discusses the different tiers of just-in-time compilation in JSC, including the low-level interpreter (LLInt), baseline JIT, and optimizing DFG JIT. It also covers techniques like lazy compilation, inline caching, and value profiling that JSC uses to improve performance. Finally, it mentions parallel garbage collection and how the engine is ported to different platforms.

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.

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.

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.

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.

1) CNN adopted GraphQL in 2016 to improve page load speeds by allowing clients to request specific data fields rather than entire documents, reducing response sizes by over 90% in some cases. 2) CNN later developed its own Data API using GraphQL and saw request volumes increase to over 7 million per hour with an 89% cache hit rate. 3) For live storytelling, CNN chose to implement Server-Sent Events which allows for near real-time updates without polling by allowing servers to push messages to clients as new data becomes available.

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.

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.

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.

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.

HTTP/2 initially seemed promising for reducing latency, but caused intermittent slowdowns for the client's critical assets. Testing revealed HTTP/2 increased median page latency by 20-30% compared to HTTP/1.1. While HTTP/2 performs well in some scenarios, it was not suitable for delivering critical assets globally due to variance issues. Over time the performance of HTTP/2 has improved, but introducing artificial latency still results in a 2.3x slowdown, so HTTP/1.1 remains a better solution for this client's critical path resources.

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.

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.

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.

This document provides a brief history of WebAssembly, including its origins in asm.js and progression through various compiler tools to the current WebAssembly standard. It discusses early implementations using asm.js for structured control flow and linear memory with isolated stacks. It also summarizes key compiler and tooling projects that have contributed to WebAssembly, such as Emscripten, Binaryen, Cranelift, Rust and WebAssembly, Pyodide, and WebAssembly Studio.

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.

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.

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.

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.

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.

Unlock the full potential of your data by effortlessly migrating from PostgreSQL to Snowflake, the leading cloud data warehouse. This comprehensive guide presents an easy-to-follow 8-step process using Estuary Flow, an open-source data operations platform designed to simplify data pipelines. Discover how to seamlessly transfer your PostgreSQL data to Snowflake, leveraging Estuary Flow's intuitive interface and powerful real-time replication capabilities. Harness the power of both platforms to create a robust data ecosystem that drives business intelligence, analytics, and data-driven decision-making. Key Takeaways: 1. Effortless Migration: Learn how to migrate your PostgreSQL data to Snowflake in 8 simple steps, even with limited technical expertise. 2. Real-Time Insights: Achieve near-instantaneous data syncing for up-to-the-minute analytics and reporting. 3. Cost-Effective Solution: Lower your total cost of ownership (TCO) with Estuary Flow's efficient and scalable architecture. 4. Seamless Integration: Combine the strengths of PostgreSQL's transactional power with Snowflake's cloud-native scalability and data warehousing features. Don't miss out on this opportunity to unlock the full potential of your data. Read & Download this comprehensive guide now and embark on a seamless data journey from PostgreSQL to Snowflake with Estuary Flow! Try it Free: https://dashboard.estuary.dev/register

Lots of bloggers are using Google AdSense now. It’s getting really popular. With AdSense, bloggers can make money by showing ads on their websites. Read this important article written by the experienced designers of the best website designing company in Delhi –

Mindfire Solutions specializes in DevOps services, facilitating digital transformation through streamlined software development and operational efficiency. Their expertise enhances collaboration, accelerates delivery cycles, and ensures scalability using cloud-native technologies. Mindfire Solutions empowers businesses to innovate rapidly and maintain competitive advantage in dynamic market landscapes.

Active Directory Audit