Tracking Performance - Velocity NYC 2013

This document discusses how to get the most out of the webpagetest.org tool for testing website performance. It provides an overview of the metrics webpagetest measures like load times, bandwidth usage, and script execution. The document also shares links to examples of using scripting commands to test service workers and customizing domain names. Additionally, it promotes Patrick Meenan's GitHub projects for Cloudflare Workers that can optimize sites and mentions the bulk testing feature on webpagetest.org.

Presentation by @aaronpeters at Dutch Web Performance Meetup on August 22 2012. The presentation covers new stuff in WPT UI, the WPT API, scripting and hidden gems. Awesome tool, but also room for improvement.

This document summarizes a presentation on debugging front-end performance issues. It discusses identifying single points of failure from third-party scripts and social widgets that can block loading. It recommends monitoring for failures, loading scripts asynchronously, and using a "black hole" to simulate outages for testing. Detection and mitigation of blocking third-party code is important to ensure fast page loads.

This document discusses integrating web performance testing into WebDriver by leveraging the WebDriver API. It proposes adding logging capabilities to WebDriver to collect performance metrics during tests without needing to integrate separate testing systems. This would allow performance data to be collected as a natural part of functional tests, improving the developer experience. The document includes examples of how to enable logging in WebDriver and access the performance log data after a test.

This document summarizes a presentation on debugging front-end performance using service workers. Service workers allow intercepting and responding to network requests and caching assets. They also support features like push notifications, offline access, and progressive web apps. The presentation covered how service workers work, common use cases like handling errors, CDN failover and prefetching, as well as future possibilities like drawing images locally and custom compression.

Presented these slides at the Google Conference that happened in Chennai. Google Developer's Group DevFest 2013

There’s no one-size-fits-all approach to metrics. In this session, Cliff Crocker and I walk through various metrics that answer performance questions from multiple perspectives — from designer and DevOps to CRO and CEO. You’ll walk away with a better understanding of your options, as well as a clear understanding of how to choose the right metric for the right audience.

Make It Fast Using Modern Browser Performance APIs to Monitor and Improve the Performance of your Web Apps. Presented at CodeMash 2015. Performance matters. How fast your site loads — not just on your development machine, but from your actual customers, across the globe — has a direct impact on your visitors’ happiness and conversion rate. Today’s browsers provide several new cutting-edge performance APIs that can give you Real User Metrics (RUM) of your live site’s performance. Whether you run a small blog or a top-1K site, monitoring and understanding your performance is the key to giving your visitors a better experience. We will be discussing the NavigationTiming, ResourceTiming and UserTiming performance APIs, which are available in the majority of modern browsers. You’ll walk away with a better understanding of what problem these APIs solve and how to start using them today. We’ll also go through both D.I.Y. and commercial options that utilize these APIs to help you better monitor and improve the performance of your websites.

Not surprisingly, there’s no one-size-fits-all performance metric (though life would be simpler if there were). Different metrics will give you different critical insights into whether or not your pages are delivering the results you want — both from your end user’s perspective and ultimately from your organization’s perspective. Join Tammy Everts, and walk through various metrics that answer performance questions from multiple perspectives. You’ll walk away with a better understanding of your options, as well as a clear understanding of how to choose the right metric for the right audience.

An approach to capturing and integrating web client Real User Measurements from the Navigation object with server-side network and HttpServer diagnostic events.

This document discusses real-time web applications and the technologies needed to enable them. It describes how HTTP is half-duplex and led to hacks like long polling to simulate real-time behavior. The WebSocket protocol provides full-duplex communications by upgrading the HTTP handshake. This allows real-time messaging over a single connection. The document also covers asynchronous programming, event-driven architectures, and frameworks like Spring that support WebSockets and asynchronous APIs.

This document discusses optimizing a Magento application before scaling it. It provides tips for optimizing server settings like Linux kernel settings in sysctl.conf to increase limits. It also recommends optimizing Nginx, PHP-FPM, Redis, and MySQL settings. For PHP-FPM, it suggests tuning the process manager and using TCP. For Redis, it advises using three instances each with its own database and port. For MySQL, it recommends turning off query caching and tuning InnoDB settings. The goal is to optimize application performance and flow before scaling to a clustered architecture.

(Talk originally given @ KCDC - http://kcdc.info ). Over the last decade, advances in web computing have removed many of the barriers to entry for developers. New languages, frameworks, and development methodologies have kickstarted new ideas and new ways to develop web applications to make modern life easier and more efficient. WebSockets (introduced as part of HTML5) is one such technology that enables a new class of scalable, super-responsive, collaborative, and real-time web applications with a wide range of uses. In this talk, we will first cover the basics of asynchronous web programming using WebSockets, including predecessors such as polling and long-polling, applications of WebSockets, its limitations and potential bottlenecks, and potential future improvements. Next, we will demo and dissect a real-world use case for realtime social data analytics, using the Apache Tomcat implementation of WebSockets and the Java-based Liferay Portal Server. This will include a discussion about development of WebSocket endpoints, its lifecycle within the application container and browser, debugging WebSockets, and scalability topics.

HTTPS & HTTP/2 This document discusses securing websites with HTTPS and migrating to HTTP/2. It provides guidance on setting up HTTPS with self-signed or free certificates. HTTP/2 improves performance over HTTPS compared to HTTP/1.1 by enabling features like server push and multiplexing. The document recommends securing all website content and resources with HTTPS to future-proof sites and unlock new browser capabilities. It also discusses optimizing for HTTPS and HTTP/2 by redirecting HTTP to HTTPS, enabling HTTP/2 via a CDN, and using HSTS.

The “caching ecosystem” has evolved over the years – what, where, and how long you cache your web assets are now important considerations for anyone doing business on the internet. Browser cache, html5 application cache, sophisticated reverse proxies like Varnish, and the evolution of CDNs have all elevated caching as the single most effective tool for creating high performing and scalable web applications. Using live demos, we will dive into some advance caching concepts that will enable you to squeeze the most benefits from this caching ecosystem, including: Prefresh Prefetching for sites Prefetching for single page apps Burst caching: caching for an extremely short burst of time, even a few seconds Dynamic page caching Cache invalidation and revalidation However, with caching power comes caching responsibility. If not implemented correctly, these advanced techniques can degrade or even break site functionality. We will conclude with some practical exercises to define the caching strategy for key use cases: E-commerce website Mobile application High traffic events.

You want a single, unicorn metric that magically sums up the user experience, business value, and numbers that DevOps cares about, but so far, you're just not getting it. So where do you start? In this talk at the 2015 Velocity conference in Santa Clara, Cliff Crocker and I walked through various metrics that answer performance questions from multiple perspectives -- from designer and DevOps to CRO and CEO.

The document discusses performance improvements in upcoming browsers. It covers new browsers like Firefox 3.1, Safari 4, Internet Explorer 8, Opera 10, and Google Chrome. These browsers will have better JavaScript engines and take advantage of new technologies like process per tab, native JSON support, and the canvas element to improve performance. Many JavaScript and CSS techniques are also described that can enhance performance by offloading work to the browser instead of through JavaScript libraries.

This presentation is about the intricacies of web performance, obstacles that impact rendering and loading time, and explores solutions that can help to reduce execution bottlenecks and rendering latency. This presentation covers the basics of the web application execution model, including the modern event loop, v8 and chromium. In addition, we will discuss and highlight APIs that could be used to optimize and monitor web performance.

This document summarizes a webinar presented by Courtney Ball, Antonio Contreras, and Whelan Boyd from 23andMe on how the company improved user experience through A/B testing and implemented Performance Edge to optimize page load times. The webinar discussed how website performance directly impacts business metrics like conversion rates, highlighted best practices for measuring performance, and explained how standard A/B testing can negatively affect page speeds. It then introduced Performance Edge as a solution that delivers only necessary code variations to visitors, significantly reducing file sizes and browser execution times. 23andMe's case study showed how implementing Performance Edge through Cloudflare Workers dramatically improved their page load performance metrics and allowed them to scale up testing without slowing down

Understanding the XPages architecture is key to building performant scalable enterprise-ready Lotus Domino web applications. We'll show how to go under the hood to discover functional features that help your application perform and scale well. You'll learn about design patterns and techniques that ensure your applications are optimally tuned for your business requirements, and we'll show how to integrate existing business logic -- without increasing performance cost.

This presentation is the first in a series on Improving Rails application performance. This session covers the basic motivations and goals for improving performance, the best way to approach a performance assessment, and a review of the tools and techniques that will yield the best results. Tools covered include: Firebug, yslow, page speed, speed tracer, dom monster, request log analyzer, oink, rack bug, new relic rpm, rails metrics, showslow.org, msfast, webpagetest.org and gtmetrix.org. The upcoming sessions will focus on: Improving sql queries, and active record use Improving general rails/ruby code Improving the front-end And a final presentation will cover how to be a more efficient and effective developer! This series will be compressed into a best of session for the 2010 http://windycityRails.org conference

Grafana/Graphite provides lightweight application performance monitoring of internal services and metrics. Rigor offers synthetic performance monitoring of selected pages from different locations. SOASTA mPulse enables real user monitoring to collect performance data from real browsers. SOASTA Data Science Workbench allows complex analysis of performance data through notebooks to answer questions about page groups, user paths, and conversion impact. Tools should be used together to gain internal and external views of performance from synthetic and real user perspectives.

Presented web vitals in Bangalore Site Speed Meetup (4th) - https://www.meetup.com/Bangalore-Site-Speed/events/270620710/

This document discusses using performance profiling and audits to identify bottlenecks in web page performance. It provides an overview of how to use the Chrome DevTools to record performance metrics and diagnose issues. Key points include: - Load time, user response times, and other performance metrics directly impact user retention and experience. - DevTools allows profiling the rendering process and identifying bottlenecks from network requests, rendering blocking assets, inefficient code using the Console, Network, Performance, and Sources panels. - Audits like Lighthouse and Webpagetest test page load performance across different conditions and help pinpoint where improvements can be made, such as first byte time, image compression, etc. - The document demonstrates using

This document discusses web application performance from a user perspective. It describes how performance testing is typically done with load generators, which can simulate many users but do not behave exactly like browsers. Factors like page size, complexity, and browser hardware impact user experience. Guidelines are provided for high performance sites, and tools like YSlow and PageSpeed are recommended for checking adherence. Both synthetic and real user measurements are important, with each having advantages and disadvantages.

Improving user experience by monitoring real user measurements data. Presented at JS-Lovers Bangalore Meetup 20th Jan 2019

This introductory-level SEO presentation will cover best practices in optimizing your website for greater organic visibility in the search engines. Learn about site structure, content optimization, on-page SEO and page speed improvements to increase your keyword rankings and bring in more qualified traffic.

This document provides an overview of the tools available in Chrome Dev Tools for web development and performance analysis. It describes the Elements, Styles, and Resources panels for inspecting and editing pages. It also covers the Network panel for analyzing resource loading, the Timeline for performance profiling, and the Audits and PageSpeed panels for optimization suggestions. Tips are provided on using these various Dev Tools to debug issues, optimize pages, and remotely debug on devices.

Performance issues are regularly caught too late leading to increased cost for fixing. We propose a process on how to make performance testing lightweight, execute it on early stages, reduce time and cost of fixes. Applying the same principal that we use for functional testing, performance testing could be integrated in CI/CD pipeline. Learn more about CPT in our blog: https://blog.griddynamics.com/what-is-continuous-performance-testing-and-why-it-is-needed

Improvements to user experience translate directly to real business metrics and the bottom line. To guide the business to making wise choices on user experience, you need an accurate picture of site performance for real users. In this talk, Steve Lerner will describe how eBay’s performance monitoring strategy has evolved, how the insights gained from real user monitoring have impacted eBay’s business, and some of the considerations that have shaped their in house implementation of Real User Monitoring to serve eBay’s massive global scale. See Steve Lerner's Edge Presentation: http://www.akamai.com/html/custconf/edgetv-commerce.html#real-user-monitoring The Akamai Edge Conference is a gathering of the industry revolutionaries who are committed to creating leading edge experiences, realizing the full potential of what is possible in a Faster Forward World. From customer innovation stories, industry panels, technical labs, partner and government forums to Web security and developers' tracks, there’s something for everyone at Edge 2013. Learn more at http://www.akamai.com/edge

As Walmart.com’s former head of Performance and Reliability, Cliff Crocker knows large scale web performance. Now SOASTA’s VP of products, Cliff is pouring his passion and expertise into cloud testing to solve the biggest challenges in mobile and web performance. The holiday rush of mobile and web traffic to your web site has the potential for unprecedented success or spectacular public failure. The world’s leading retailers have turned to the cloud to assure that no matter what load, mobile and web apps will delight customers and protect revenue. Join us as Cliff explores the key criteria for holiday web performance readiness: Closing the gap in front- and back-end web performance and reliability Collecting real user data to define the most realistic test scenarios Preparing properly for the virtual walls of traffic during peak events Leveraging CloudTest technology, as have 6 of 10 leading retailers

This document discusses Browserscope, an open-source project that crowdsources browser testing to profile browser capabilities and performance. It collects data from over 10,000 browsers to track functionality over time, uncover regressions, and provide a historical resource for web developers. Tests are run on real users' browsers to aggregate unbiased results without dedicated testing resources.

Full webinar recording can be found here: https://youtu.be/zlRLui6WC7M -------- Digital makes the world go ‘round, and it’s software quality on the one hand, and speed of delivery on the other, that make or break today’s business endeavours. In the era of digital experience, where the user is king, achieving quality is crucial to a business’s success -- but speed of delivery cannot be ignored anymore, or you will feel your competition breathing down your neck. Therefore, continuous refinement of the Dev-Test-Deploy pipeline is how businesses strive to achieve both quality and speed of delivery. In this unique session we will combine insider’s knowledge of industry trends and key shifts, alongside hands-on tools, tips, and best practices -- all of which will directly affect your day-to-day work processes, through-out the entire product release lifecycle. Listen to guest speaker Diego Lo Giudice (Vice President, Principal Analyst at Forrester) and Gil Tayar (Sr. Architect at Applitools), and learn: * Industry overview, importance of test automation, and where is this all going * Importance of digital experience on the bottom line – and how companies address this in their dev-test processes * AI-powered tools and solutions: how do they factor in to the agile and test automation equation * Agile, Automation and CI-CD: How visual testing must too be automated with Agile and DevOps, as part of the Continuous Delivery capabilities and practices * Real life use cases and a live demo from Applitools

Slides from my 4-hour workshop on Client-Side Performance Testing conducted at Phoenix, AZ in STPCon 2017 (March). Workshop Takeaways: Understand difference between is Performance Testing and Performance Engineering. Hand’s on experience of some open-source tools to monitor, measure and automate Client-side Performance Testing. Examples / code walk-through of some ways to automate Client-side Performance Testing. See blog for more details - https://essenceoftesting.blogspot.com/2017/03/workshop-client-side-performance.html

Having problems with your website’s performance? Does it take too much time and effort to determine the cause of a particular page’s poor performance? Would you like to find the root cause of client-side issues in an automated way? If you answered yes to any of these questions, then this session is for you. At GSI Commerce, an eBay company, Ron Woody manages a large team of performance engineers working on nearly nearly 100 eCommerce websites. Ron and his team have developed cutting-edge approaches for automating client- and server-side performance testing. Learn the specific approaches Ron’s team uses today for pre-release performance tests, production performance management, and website optimization. Find out the ways they’ve automated cross-browser performance testing—and analysis—to increase productivity and efficiency. Covering these and additional topics Ron shares a toolkit of performance testing ideas and approaches your team can use to ensure optimal application performance and a better user experience.

This document discusses web performance optimization and provides tips to improve performance. It emphasizes that performance is important for user experience, search engine optimization, conversion rates, and costs. It outlines common causes of performance issues like round-trip times, payload sizes, browser rendering delays, and inefficient JavaScript. Specific recommendations are given to optimize images, stylesheets, scripts, and browser rendering through techniques like compression, caching, deferred loading, and efficient coding practices. A variety of tools for measuring and improving performance are also listed.

Session presented by Shweta Sharma of Axelerant on Advanced Automated Visual testing at DrupalCon Seattle 2019

This document discusses resource prioritization strategies to optimize loading performance. It explains that the browser processes resources sequentially and blocks on certain resource types. It then provides recommendations for developers to inform the browser of dependencies and priorities through techniques like preloading. The document also analyzes HTTP/1.x versus HTTP/2 prioritization and compares performance of loading scripts and fonts with different approaches. It evaluates tools for testing prioritization and discusses why prioritization can fail or appear broken. Finally, it offers suggestions for servers and networks to better support prioritization.

This document discusses HTTP/2 prioritization and how resources are prioritized during loading. It begins by explaining how browsers prioritize different resource types during parsing and rendering. It then covers how HTTP/2 allows all requests to be sent immediately to the server with priority specifications, as opposed to HTTP/1.x which limits connections. The document concludes by discussing challenges with prioritization across connections and various tools for testing prioritization.

Slides from Velocity 2019 tutorial on HTTP/2. Covers prioritization in the browser, network and server and tuning of HTTP/2.

The document discusses key aspects of resource loading and prioritization on the web, including: 1. The HTML parser stops for non-async scripts until previous CSS is downloaded and the script is parsed and executed, but does not pause for CSS or image loading. 2. Resources can only be loaded once discovered by the parser or layout; optimal ordering prioritizes render-blocking and parser-blocking resources first using full bandwidth. 3. HTTP/2 allows for prioritization of resources from a single domain, while priority hints and preloading help prioritize cross-domain assets.

This document discusses various metrics for measuring website speed and performance. It outlines different technical, visual, and interactive metrics and explains considerations for synthetic versus real-user measurement. Key recommendations include using First Contentful Paint, Speed Index from synthetic tests and First Interactive for real-user measurement to track progress towards performance goals. Effective connection type distribution from real-user data should also be considered to ensure optimizations work for all users.

Presentation from Velocity 2016 on using Machine Learning to determine the metrics that drive bounce and conversions

This document summarizes a presentation on debugging front-end performance related to TLS and HTTPS. It discusses optimizing the TLS handshake to reduce round trips, using session resumption, OCSP stapling, TLS false start, and dynamic record sizing. It also covers TLS debugging tools like istlsfastyet.com and security headers like HSTS, CSP, and HPKP. The presentation aimed to provide practical techniques and checks to improve TLS performance in practice.

This document discusses various methods for measuring front-end performance, including synthetic testing, active testing, real user measurement, and measuring the visual experience. Synthetic testing provides consistent results but may not reflect actual user performance, while real user measurement captures real user experiences but with limited detail. The document also covers specific tools like Navigation Timing, Resource Timing, User Timing, SpeedIndex, and services from companies like Soasta, New Relic, and WebPageTest that can help with performance measurement.