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.
The document discusses responsive interfaces and how to keep the user interface responsive when executing JavaScript. It explains that the UI thread is used for both drawing updates and running JavaScript, so no updates can happen while JavaScript runs. It recommends keeping JavaScript execution under 50ms to avoid unresponsiveness, and describes using timers and web workers to split processing over multiple ticks to keep the UI responsive.
Electron is a fantastic tool for creating cross-platform apps with HTML, CSS, and JavaScript that look and feel relatively native to the hosted Platform. In this presentation I'll give a quick overview of what's possible.
Overhauling one of the most visited web sites in the world is a major task, and add on top of it the pressure of keeping performance the same while adding a ton of new features, and you have quite a task. Learn how the Yahoo! homepage team achieved performance parity with the previous version even while adding a ton of new features.
The document summarizes techniques for improving JavaScript performance in web applications. It discusses how JavaScript execution blocks the browser UI thread, leading to unresponsive user experiences if scripts run for too long. It then provides recommendations to limit JavaScript execution times to under 50ms and describes load time techniques like placing scripts at the bottom of the page, combining files, and loading scripts dynamically or deferring their execution to improve page load performance.
Measuring the visual experience of website performance
This document discusses different methods for measuring website performance from both a synthetic and real-user perspective. It introduces the Speed Index metric for quantifying visual progress and compares the Speed Index of Amazon and Twitter. It also covers the Chrome resource prioritization and different challenges around visual performance metrics.
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.
After consulting with several companies on performance related issues, it became clear that one of the biggest performance issues facing websites today is the sheer amount of JavaScript needed to power the page. The demand for more interactive and responsive applications has driven JavaScript usage through the roof. It’s quite common for large sites to end up with over 1 MB of JavaScript code on their page even after minification. But do today’s web applications really need that much JavaScript?
Building performance into the new yahoo homepage presentation
Nicholas Zakas presented on optimizing the performance of the Yahoo homepage redesign from 2010. The new design added significant functionality but also increased page size and complexity, threatening performance. Areas of focus included reducing time to interactivity, improving Ajax responsiveness, and managing perceived performance. Through techniques like progressive rendering, non-blocking JavaScript loading, and indicating loading states, performance was improved and maintained users' perception of speed. The redesign achieved onload times of ~2.5 seconds, down from ~5 previously, while perceived performance matched the previous version.
2 parts of talking at Google Developer Summit 2016 Seoul
- How to optimize loading performance your web app
- Introducing to Service Worker & Offline 101
JavaScript Timers, Power Consumption, and Performance
This document discusses how timers, power consumption, and performance are related on web pages. It explains that CPUs can enter low-power sleep states when idle, but timers used in JavaScript can prevent this and increase power usage. The document recommends using higher interval timers (over 15ms) when possible to improve battery life on mobile devices. It also notes that having too many concurrent timers can flood the browser's queue and negatively impact rendering performance.
The document discusses performance testing plans for a website. It proposes using synthetic testing from 14 global locations on representative pages every 5 minutes. A new plan tests from last-mile locations on desktop and mobile with 20 daily samples. Custom timing marks will measure user experience, sent to analytics. Synthetic testing will also run in continuous integration to catch performance regressions early.
For much of its existence, JavaScript has been slow. No one complained until developers created complex web applications with thousands of lines of JavaScript code. Although newer JavaScript engines have improved the situation, there's still a lot to understand about what makes JavaScript slow and what you can do to speed up your code.
Selecting and deploying automated optimization solutions
This document discusses various methods for automating front-end optimization. It describes how HTML rewriting solutions can optimize HTML through proxies or in-app plugins. It also discusses when certain optimizations are best done by machines versus humans. The document outlines different architectures for front-end optimization solutions, including cloud-based and on-premises options, and considers when each is most appropriate. It emphasizes the importance of testing solutions before deploying and of monitoring performance after deployment.
Ever wonder why the page appears frozen or why you get a dialog saying, "this script is taking too long"? Inside of the browser, JavaScript and the page's UI are very intertwined, which means they can affect each other and, in turn, affect overall page performance. Ensuring the fastest execution time of JavaScript code isn't about geek cred, it's about ensuring that the user experience is as fast and responsive as possible. In a world where an extra second can cost you a visitor, sluggishness due to poor JavaScript code is a big problem. In this talk, you'll learn what's going on inside the browser that can slow JavaScript down and how that can end up creating a "slow page". You'll also learn how to overcome the conspiracy against your code by eliminating performance bottlenecks.
Disrupting the application eco system with progressive web applications
Progressive Web Applications (PWA) is a comprehensive term describing web applications that implement a base set of browser platform features like HTTPS, Web Manifest and Service Workers. But it bleeds beyond the scope of an application's code because browsers are enabling qualified web applications to offer the same user experiences native application enjoy. This includes prominent home screen placement, push notifications, eliminated browser chrome and app store placement.
Become a Progressive Web App expert with my course: Progressive Web Apps (PWA) Beginner to Expert -> http://PWACourse.com
Castles in the Cloud: Developing with Google App Engine
App Engine offers developers the opportunity to deploy systems on Google's robust and scalable server-farms. App Engine provides a higher-level platform than Amazon Web Services,with automated scaling and true pay-per-use billing.
The poster-child of App Engine, "BuddyPoke", has gained over thirty million users.
With App Engine, Google has released the first public API to BigTable, its planetary datastore, which performs successfully at petabyte scale across diverse applications from search to finance to Google Earth.
This presentation will cover App Engine's features and limitations, and how to exploit this new and evolving platform.
This document discusses PageSpeed, a tool for just-in-time performance optimization of web pages. It provides automatic image compression and resizing, CSS and JavaScript minification, inline small files, caching, and deferring JavaScript among other optimizations. While most performance issues are well understood, not all websites are fast due to the tradeoff between speed and ease of maintenance. PageSpeed tools like mod_pagespeed can automate optimizations to improve performance without extra work from developers.
Metrics, metrics everywhere (but where the heck do you start?)
This document discusses various metrics for measuring website performance and user experience. It outlines different types of metrics including:
- Network metrics like DNS resolution, TCP connection times, and time to first byte.
- Browser metrics like start render time, DOM loading/ready times, and page load times.
- Resource-level metrics obtained from the Resource Timing API like individual asset load times and response sizes.
- User-centric metrics like Speed Index, time to visible content, and metrics for single-page applications without traditional page loads.
It emphasizes the importance of measuring real user monitoring data alongside synthetic tests, and looking at higher percentiles rather than just averages due to variability in user environments and network conditions
Velocity NYC: Metrics, metrics everywhere (but where the heck do you start?)
This document discusses various metrics for measuring website performance. It begins by noting that there are many metrics to consider and no single metric tells the whole story. It then discusses several key metrics for measuring different aspects of performance, including:
- Front-end metrics like start render, DOM loading/ready, and page load that can isolate front-end from back-end performance.
- Network metrics like DNS and TCP timings that provide insight into connectivity issues.
- Resource timing metrics that measure individual assets to understand impacts of third parties and CDNs.
- User timing metrics like measuring above-the-fold content that capture user experience.
It emphasizes the importance of considering real user monitoring data alongside
Metrics, metrics everywhere (but where the heck do you start?)
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.
This presentation attempts to make assumptions used in popular web performance tools like YSlow and webpagetest explicit. It also looks at the NavTiming API and explores ways to capture RUM measurements and correlate them with server-side metrics.
It is all about a huge knowledge chasm created by a few years out of practical programming and especially without experiencing web programming. This speech is about many of us that have knowledge of programming other technologies and have to face a new challenge, in this case: developing a web application.
This document discusses modern web applications using progressive web apps (PWA) and WebAssembly (WASM). It begins by defining a web application and describing challenges like performance issues. It then introduces PWAs and WASM as solutions, explaining what they are, how they work, and providing examples. The document shares links to starter kits and success stories to help readers get started with building modern web apps using these technologies.
The document discusses user experience management and outlines various web performance metrics that can be captured from browsers such as time-to-first-byte, onload time, bandwidth, rendering time, and resource download times. It describes the W3C Navigation Timing and Resource Timing APIs that browsers expose to capture this performance data non-intrusively. Examples are provided of how this data could be used for real-world applications like identifying geo hotspots, page error monitoring, and performance profiling.
Monitoring web application response times^lj a hybrid approach for windows
This document discusses web application performance monitoring and summarization. It covers tools like YSlow for analyzing page load times, and introduces an approach using Event Tracing for Windows (ETW) to capture performance data from web applications. This includes intercepting Yahoo Boomerang beacon requests to generate ETW events with page load time measurements and other data for analysis. A Web Application Trace Explorer is demonstrated to filter and report on these events to help explore server-side event streams and web application performance.
Performance is the most important attribute for success of any commercial and Enterprise Software. In a client server environment, developers focus a lot on optimizing the Data and Logical Tiers. Optimization of Presentation Tier which is responsible for more than 30 % of performance is usually ignored.
The document is developed with the intension to teach the technical staff on Optimizing the Presentation Tier which significantly improves the performance of the Client Server applications.
Sherlock Homepage - A detective story about running large web services - NDC ...
The site was slow. CPU and memory usage everywhere! Some dead objects in the corner. Something terrible must have happened! We have some IIS logs. Some traces from a witness. But not enough to find out what was wrong. In this session, we’ll see how effective telemetry, a profiler or two as well as a refresher of how IIS runs our ASP.NET web applications can help solve this server murder mystery.
Introduction to JQuery, ASP.NET MVC and Silverlight
This document provides an overview of a presentation on jQuery, ASP.NET MVC, and Silverlight. It discusses jQuery being a lightweight JavaScript library that makes web development simpler. ASP.NET MVC is presented as an alternative to WebForms that separates concerns into models, views, and controllers. Silverlight is introduced as a technology for building rich interactive applications for the web using .NET.
Sherlock Homepage - A detective story about running large web services - WebN...
The site was slow. CPU and memory usage everywhere! Some dead objects in the corner. Something terrible must have happened! We have some IIS logs. Some traces from a witness. But not enough to find out what was wrong. In this session, we’ll see how effective telemetry, a profiler or two as well as a refresher of how IIS runs our ASP.NET web applications can help solve this server murder mystery.
The site was slow. CPU and memory usage everywhere! Some dead objects in the corner. Something terrible must have happened! We have some IIS logs. Some traces from a witness. But not enough to find out what was wrong. In this session, we’ll see how effective telemetry, a profiler or two as well as a refresher of how IIS runs our ASP.NET web applications can help solve this server murder mystery.
Sherlock Homepage - A detective story about running large web services (VISUG...
The site was slow. CPU and memory usage everywhere! Some dead objects in the corner. Something terrible must have happened! We have some IIS logs. Some traces from a witness. But not enough to find out what was wrong. In this session, we’ll see how effective telemetry, a profiler or two as well as a refresher of how IIS runs our ASP.NET web applications can help solve this server murder mystery.
Cloud APIs provide programmatic access to cloud resources and services. They allow developers to interact with applications, development environments, and raw compute/storage resources through standardized interfaces. While each cloud provider currently has their own proprietary APIs, there is a push for open standards to accelerate development of higher-level services and commoditization of basic resources. Key areas for a common cloud API include resource representations, security requirements, and orchestration of ensembles of resources across providers.
Stardust is a mature, industry-proven business process management suite that is now available as an open source project under the Eclipse Public License. It includes capabilities for workflow, system integration, and document management. Stardust has seen production deployments with over 10,000 users, 1,000,000 processes per day, and 300,000 documents per day. The codebase consists of over 3 million lines of code and 200 third-party libraries. The Stardust community is actively enhancing the knowledge base and collaborating with other projects.
This document discusses how HTML5 can be used to build engaging mobile applications. Key features covered include offline storage using the Application Cache API, storing data locally using Web Storage, using a SQL database with Web SQL, advanced graphics capabilities with Canvas and SVG, real-time communications over WebSockets, and tools for developing HTML5 apps like jQuery Mobile, Sencha Touch, and Google Web Toolkit. It emphasizes testing on multiple platforms and browsers to ensure compatibility.
Metrics, metrics everywhere (but where the heck do you start?)
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.
Metrics, Metrics Everywhere (but where the heck do you start?)
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.
Metrics, Metrics Everywhere (but where the heck do you start?)
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.
What is a “modern” metric anyway? An exploration on how to measure and evaluate popular (and experimental) web performance metrics, and how they affect user happiness and business goals.
We'll talk about how data can be biased, and how best to interpret performance data given those biases. We'll look at a broad set of RUM data we've captured to see how the Core Web Vitals correlate (or not) to other performance and business metrics. Finally, we'll share a new way that others can research modern metrics and RUM data.
Check Yourself Before You Wreck Yourself: Auditing and Improving the Performa...
Boomerang is an open-source Real User Monitoring (RUM) JavaScript library used by thousands of websites to measure their visitor's experiences. The developers behind Boomerang take pride in building a reliable and performant third-party library that everyone can use without being concerned about its measurements affecting their site. We recently performed and shared an audit of Boomerang's performance, to help communicate its "cost of doing business", and in doing so we found several areas of code that we wanted to improve. We'll discuss how we performed the audit, some of the improvements we've made, how we're testing and validating our changes, and the real-time telemetry we capture for our library to ensure we're having as little of an impact as possible on the sites we're included on.
Boomerang is an open-source Real User Monitoring (RUM) JavaScript library used by thousands of websites to measure their visitor's experiences.
Boomerang runs on billions of page loads a day, either via the open-source library or as part of Akamai's mPulse RUM service. The developers behind Boomerang take pride in building a reliable and performant third-party library that everyone can use without being concerned about its measurements affecting their site.
Recently, we performed and shared an audit of Boomerang's performance, to help communicate the "cost of doing business" of including Boomerang on a page while it takes its measurements. In doing the audit, we found several areas of code that we wanted to improve and have been making continuous improvements ever since. We've taken ideas and contributions from the OSS community, and have built a Performance Lab that helps "lock in" our improvements by continuously measuring the metrics that are important to us.
We'll discuss how we performed the audit, some of the improvements we've made, how we're testing and validating our changes, and the real-time telemetry we capture on our library to ensure we're having as little of an impact as possible on the sites we're included on.
When Third Parties Stop Being Polite... and Start Getting Real
By Nic Jansma and Charlie Vazac (Akamai)
Fluent 2018
Would you give the Amazon Prime delivery robot the key to your house, just because it stops by to deliver delicious packages every day? Even if you would, do you still have 100% confidence that it wouldn’t accidentally drag in some mud, let the neighbor in, steal your things, or burn your house down? Worst-case scenarios such as these are what you should be planning for when deciding whether or not to include third-party libraries and services on your website. While most libraries have good intentions, by including them on your site, you have given them complete control over the kingdom. Once on your site, they can provide all of the great services you want—or they can destroy everything you’ve worked so hard to build.
It’s prudent to be cautious: we’ve all heard stories about how third-party libraries have caused slowdowns, broken websites, and even led to downtime. But how do you evaluate the actual costs and potential risks of a third-party library so you can balance that against the service it provides? Every library requires nonzero overhead to provide the service it claims. In many cases, the overhead is minimal and justified, but we should quantify it to understand the real cost. In addition, libraries need to be carefully crafted so they can avoid causing additional pain when the stars don’t align and things go wrong.
Nic Jansma and Charles Vazac perform an honest audit of several popular third-party libraries to understand their true cost to your site, exploring loading patterns, SPOF avoidance, JavaScript parsing, long tasks, runtime overhead, polyfill headaches, security and privacy concerns, and more. From how the library is loaded, to the moment it phones home, you’ll see how third-parties can affect the host page and discover best practices you can follow to ensure they do the least potential harm.
With all of the great performance tools available to developers today, we’ve gained a lot of insight into just how much third-party libraries are impacting our websites. Nic and Charles detail tools to help you decide if a library’s risks and unseen costs are worth it. While you may not have the time to perform a deep dive into every third-party library you want to include on your site, you’ll leave with a checklist of the most important best practices third-parties should be following for you to have confidence in them.
Responsiveness to user interaction is crucial for users of web apps, and businesses need to be able to measure responsiveness so they can be confident that their users are happy. Unfortunately, users are regularly bogged down by frustrations such as a delayed "time to interactive” during page load, high or variable input latency on critical interaction events (tap, click, scroll, etc.), and janky animations or scrolling. These negative experiences turn away visitors, affecting the bottom line. Sites that include third-party content (ads, social plugins, etc.) are frequently the worst offenders.
The culprit behind all these responsiveness issues are “long tasks," which monopolize the UI thread for extended periods and block other critical tasks from executing. Developers lack the necessary APIs and tools to measure and gain insight into such problems in the wild and are essentially flying blind trying to figure out what the main offenders are. While developers are able to measure some aspects of responsiveness, it’s often not in a reliable, performant, or “good citizen” way, and it’s near impossible to correctly identify the perpetrators.
Shubhie Panicker and Nic Jansma share new web performance APIs that enable developers to reliably measure responsiveness and correctly identify first- and third-party culprits for bad experiences. Shubhie and Nic dive into real-user measurement (RUM) web performance APIs they have developed: standardized web platform APIs such as Long Tasks as well as JavaScript APIs that build atop platform APIs, such as Time To Interactive. Shubhie and Nic then compare these measurements to business metrics using real-world data and demonstrate how web developers can detect issues and reliably measure responsiveness in the wild—both at page load and postload—and thwart the culprits, showing you how to gather the data you need to hold your third-party scripts accountable.
To people responsible for the health of web properties, monitoring, measurement, and analysis of real-user experiences is key to delivering a consistent and delightful experience. Drawing on their experience with the open source boomerang project, Philip Tellis and Nic Jansma explore various tools and methods available to measure real-user performance in the browser.
Topics include:
Available browser APIs: Navigation Timing, Resource Timing (Levels 1 and 2), User Timing, Error Logging, and more
Measuring full-page apps
Measuring single-page apps
RUM SpeedIndex
Measuring continuity
Hacks when an API isn’t available
Avoiding the observer effect
Filtering data to get rid of noise
Identifying outliers and treating them differently
Measuring the Performance of Single Page Applications
Single page applications are a problem for RUM tools because there are no easy ways to tell when a new page component has been requested asynchronously as a result of an intentional user action. Many network requests are back-end service calls initiated periodically by the app – for example, a ping to check if content has been updated, or to check if the current user should still be signed in to their account.
Even with requests that are initiated by a user action, not all may fit into the definition of a “page view.” For example, a user typing into a search box that has auto-complete capabilities will often result in network requests, but these requests result in very small amounts of data transfer, happen very frequently, and do not count toward page views. The scene is further complicated by SPA frameworks like Angular, Backbone, and others.
In this talk, we’ll learn about some of the tricks used by boomerang to measure the performance of single page applications, going as far as capturing errors and waterfall information across browsers.
This document discusses JavaScript module patterns, which help organize and limit the scope of code in projects. It covers different patterns for creating objects and modules, including using constructors, prototypes, the revealing module pattern, CommonJS, and AMD. The basic module pattern allows defining private and public members to encapsulate data and functions. Later patterns like CommonJS and AMD build on this to support asynchronous loading and use in different environments like the browser and Node.js.
Sails.js is a MVC web framework for Node.js built on Express. It is inspired by frameworks like Ruby on Rails and uses conventions over configurations. Sails.js features include a database-agnostic ORM, auto-generated REST APIs, and easy WebSocket integration. To get started, install Sails.js globally and use the sails command to generate a new project, lift the app, and generate models, controllers and REST APIs.
Appcelerator Titanium is a cross-platform development environment where you can build iOS, Android, BlackBerry and Hybrid/HTML5 apps. This talk will discuss how it works, how to get started, code samples and pros/cons from experience.
The document outlines a strategy for migrating an existing ASP.NET MVC and MongoDB todo application to use Node.js. It proposes a 4 phase approach: 1) Build a Node.js API and integrate it with the Angular frontend, 2) Add an admin interface with real-time monitoring, 3) Allow horizontal scaling of Node instances, and 4) Fully migrate the existing ASP.NET MVC API to Node.js to see performance improvements. Each phase is demonstrated with code examples and a running prototype. The overall goal is to prototype new features faster using Node.js before committing to a full migration.
Phing is a PHP build tool, similar to Apache's Ant. Phing can be used for everything from validating your build, running tests, combining/minifying resources to deploying.
- Nic Jansma is a developer who previously worked at Microsoft and recently founded Wolverine Digital to develop high-performance websites and apps.
- He used Appcelerator Titanium to build cross-platform mobile apps, including a LEGO Minifigure catalog app, allowing him to write code once and deploy to both iOS and Android.
- While Titanium allowed cross-platform development, Nic still encountered platform-specific issues and the need to occasionally write platform-specific code, but found Titanium a good choice overall for his needs.
These fighter aircraft have uses outside of traditional combat situations. They are essential in defending India's territorial integrity, averting dangers, and delivering aid to those in need during natural calamities. Additionally, the IAF improves its interoperability and fortifies international military alliances by working together and conducting joint exercises with other air forces.
Advanced Techniques for Cyber Security Analysis and Anomaly Detection
Cybersecurity is a major concern in today's connected digital world. Threats to organizations are constantly evolving and have the potential to compromise sensitive information, disrupt operations, and lead to significant financial losses. Traditional cybersecurity techniques often fall short against modern attackers. Therefore, advanced techniques for cyber security analysis and anomaly detection are essential for protecting digital assets. This blog explores these cutting-edge methods, providing a comprehensive overview of their application and importance.
RPA In Healthcare Benefits, Use Case, Trend And Challenges 2024.pptx
Your comprehensive guide to RPA in healthcare for 2024. Explore the benefits, use cases, and emerging trends of robotic process automation. Understand the challenges and prepare for the future of healthcare automation
Quality Patents: Patents That Stand the Test of Time
Is your patent a vanity piece of paper for your office wall? Or is it a reliable, defendable, assertable, property right? The difference is often quality.
Is your patent simply a transactional cost and a large pile of legal bills for your startup? Or is it a leverageable asset worthy of attracting precious investment dollars, worth its cost in multiples of valuation? The difference is often quality.
Is your patent application only good enough to get through the examination process? Or has it been crafted to stand the tests of time and varied audiences if you later need to assert that document against an infringer, find yourself litigating with it in an Article 3 Court at the hands of a judge and jury, God forbid, end up having to defend its validity at the PTAB, or even needing to use it to block pirated imports at the International Trade Commission? The difference is often quality.
Quality will be our focus for a good chunk of the remainder of this season. What goes into a quality patent, and where possible, how do you get it without breaking the bank?
** Episode Overview **
In this first episode of our quality series, Kristen Hansen and the panel discuss:
⦿ What do we mean when we say patent quality?
⦿ Why is patent quality important?
⦿ How to balance quality and budget
⦿ The importance of searching, continuations, and draftsperson domain expertise
⦿ Very practical tips, tricks, examples, and Kristen’s Musts for drafting quality applications
https://www.aurorapatents.com/patently-strategic-podcast.html
Measuring the Impact of Network Latency at Twitter
Widya Salim and Victor Ma will outline the causal impact analysis, framework, and key learnings used to quantify the impact of reducing Twitter's network latency.
Blockchain technology is transforming industries and reshaping the way we conduct business, manage data, and secure transactions. Whether you're new to blockchain or looking to deepen your knowledge, our guidebook, "Blockchain for Dummies", is your ultimate resource.
Implementations of Fused Deposition Modeling in real world
The presentation showcases the diverse real-world applications of Fused Deposition Modeling (FDM) across multiple industries:
1. **Manufacturing**: FDM is utilized in manufacturing for rapid prototyping, creating custom tools and fixtures, and producing functional end-use parts. Companies leverage its cost-effectiveness and flexibility to streamline production processes.
2. **Medical**: In the medical field, FDM is used to create patient-specific anatomical models, surgical guides, and prosthetics. Its ability to produce precise and biocompatible parts supports advancements in personalized healthcare solutions.
3. **Education**: FDM plays a crucial role in education by enabling students to learn about design and engineering through hands-on 3D printing projects. It promotes innovation and practical skill development in STEM disciplines.
4. **Science**: Researchers use FDM to prototype equipment for scientific experiments, build custom laboratory tools, and create models for visualization and testing purposes. It facilitates rapid iteration and customization in scientific endeavors.
5. **Automotive**: Automotive manufacturers employ FDM for prototyping vehicle components, tooling for assembly lines, and customized parts. It speeds up the design validation process and enhances efficiency in automotive engineering.
6. **Consumer Electronics**: FDM is utilized in consumer electronics for designing and prototyping product enclosures, casings, and internal components. It enables rapid iteration and customization to meet evolving consumer demands.
7. **Robotics**: Robotics engineers leverage FDM to prototype robot parts, create lightweight and durable components, and customize robot designs for specific applications. It supports innovation and optimization in robotic systems.
8. **Aerospace**: In aerospace, FDM is used to manufacture lightweight parts, complex geometries, and prototypes of aircraft components. It contributes to cost reduction, faster production cycles, and weight savings in aerospace engineering.
9. **Architecture**: Architects utilize FDM for creating detailed architectural models, prototypes of building components, and intricate designs. It aids in visualizing concepts, testing structural integrity, and communicating design ideas effectively.
Each industry example demonstrates how FDM enhances innovation, accelerates product development, and addresses specific challenges through advanced manufacturing capabilities.
Hands on performance testing and analysis with web pagetestPatrick Meenan
WebPagetest is a tool that tests the performance of web pages from multiple locations worldwide with configurable connectivity settings. It provides metrics like page speed scores, timings, bytes transferred, and screenshots. Key features include blocking content to test impact on performance, and scripting to automate testing of rich applications. The tool has a REST API for automating tests and integrating with other tools.
Forensic Tools for In-Depth Performance InvestigationsNicholas Jansma
Boomerang is a JavaScript library that gathers performance metrics of page loads. When a customer saw periods where nothing progressed on their site, forensic tools were used to investigate. WebPageTest reproduced the issue, and tcpdump, Wireshark, and Chrome Tracing helped dive deeper. Tests showed the problem was not related to Boomerang. Other scenarios involved issues with ready state changes and prematurely expiring CSRF tokens. Various tools like the browser dev tools, Fiddler, and Node.js were used to reproduce problems and validate fixes.
The document discusses responsive interfaces and how to keep the user interface responsive when executing JavaScript. It explains that the UI thread is used for both drawing updates and running JavaScript, so no updates can happen while JavaScript runs. It recommends keeping JavaScript execution under 50ms to avoid unresponsiveness, and describes using timers and web workers to split processing over multiple ticks to keep the UI responsive.
Building Cross Platform Apps with ElectronChris Ward
Electron is a fantastic tool for creating cross-platform apps with HTML, CSS, and JavaScript that look and feel relatively native to the hosted Platform. In this presentation I'll give a quick overview of what's possible.
Overhauling one of the most visited web sites in the world is a major task, and add on top of it the pressure of keeping performance the same while adding a ton of new features, and you have quite a task. Learn how the Yahoo! homepage team achieved performance parity with the previous version even while adding a ton of new features.
High Performance JavaScript (Amazon DevCon 2011)Nicholas Zakas
The document summarizes techniques for improving JavaScript performance in web applications. It discusses how JavaScript execution blocks the browser UI thread, leading to unresponsive user experiences if scripts run for too long. It then provides recommendations to limit JavaScript execution times to under 50ms and describes load time techniques like placing scripts at the bottom of the page, combining files, and loading scripts dynamically or deferring their execution to improve page load performance.
Measuring the visual experience of website performancePatrick Meenan
This document discusses different methods for measuring website performance from both a synthetic and real-user perspective. It introduces the Speed Index metric for quantifying visual progress and compares the Speed Index of Amazon and Twitter. It also covers the Chrome resource prioritization and different challenges around visual performance metrics.
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.
After consulting with several companies on performance related issues, it became clear that one of the biggest performance issues facing websites today is the sheer amount of JavaScript needed to power the page. The demand for more interactive and responsive applications has driven JavaScript usage through the roof. It’s quite common for large sites to end up with over 1 MB of JavaScript code on their page even after minification. But do today’s web applications really need that much JavaScript?
Building performance into the new yahoo homepage presentationmasudakram
Nicholas Zakas presented on optimizing the performance of the Yahoo homepage redesign from 2010. The new design added significant functionality but also increased page size and complexity, threatening performance. Areas of focus included reducing time to interactivity, improving Ajax responsiveness, and managing perceived performance. Through techniques like progressive rendering, non-blocking JavaScript loading, and indicating loading states, performance was improved and maintained users' perception of speed. The redesign achieved onload times of ~2.5 seconds, down from ~5 previously, while perceived performance matched the previous version.
Instant and offline apps with Service WorkerChang W. Doh
2 parts of talking at Google Developer Summit 2016 Seoul
- How to optimize loading performance your web app
- Introducing to Service Worker & Offline 101
JavaScript Timers, Power Consumption, and PerformanceNicholas Zakas
This document discusses how timers, power consumption, and performance are related on web pages. It explains that CPUs can enter low-power sleep states when idle, but timers used in JavaScript can prevent this and increase power usage. The document recommends using higher interval timers (over 15ms) when possible to improve battery life on mobile devices. It also notes that having too many concurrent timers can flood the browser's queue and negatively impact rendering performance.
The document discusses performance testing plans for a website. It proposes using synthetic testing from 14 global locations on representative pages every 5 minutes. A new plan tests from last-mile locations on desktop and mobile with 20 daily samples. Custom timing marks will measure user experience, sent to analytics. Synthetic testing will also run in continuous integration to catch performance regressions early.
High Performance JavaScript - Fronteers 2010Nicholas Zakas
For much of its existence, JavaScript has been slow. No one complained until developers created complex web applications with thousands of lines of JavaScript code. Although newer JavaScript engines have improved the situation, there's still a lot to understand about what makes JavaScript slow and what you can do to speed up your code.
Selecting and deploying automated optimization solutionsPatrick Meenan
This document discusses various methods for automating front-end optimization. It describes how HTML rewriting solutions can optimize HTML through proxies or in-app plugins. It also discusses when certain optimizations are best done by machines versus humans. The document outlines different architectures for front-end optimization solutions, including cloud-based and on-premises options, and considers when each is most appropriate. It emphasizes the importance of testing solutions before deploying and of monitoring performance after deployment.
High Performance JavaScript (YUIConf 2010)Nicholas Zakas
Ever wonder why the page appears frozen or why you get a dialog saying, "this script is taking too long"? Inside of the browser, JavaScript and the page's UI are very intertwined, which means they can affect each other and, in turn, affect overall page performance. Ensuring the fastest execution time of JavaScript code isn't about geek cred, it's about ensuring that the user experience is as fast and responsive as possible. In a world where an extra second can cost you a visitor, sluggishness due to poor JavaScript code is a big problem. In this talk, you'll learn what's going on inside the browser that can slow JavaScript down and how that can end up creating a "slow page". You'll also learn how to overcome the conspiracy against your code by eliminating performance bottlenecks.
Disrupting the application eco system with progressive web applicationsChris Love
Progressive Web Applications (PWA) is a comprehensive term describing web applications that implement a base set of browser platform features like HTTPS, Web Manifest and Service Workers. But it bleeds beyond the scope of an application's code because browsers are enabling qualified web applications to offer the same user experiences native application enjoy. This includes prominent home screen placement, push notifications, eliminated browser chrome and app store placement.
Become a Progressive Web App expert with my course: Progressive Web Apps (PWA) Beginner to Expert -> http://PWACourse.com
Castles in the Cloud: Developing with Google App Enginecatherinewall
App Engine offers developers the opportunity to deploy systems on Google's robust and scalable server-farms. App Engine provides a higher-level platform than Amazon Web Services,with automated scaling and true pay-per-use billing.
The poster-child of App Engine, "BuddyPoke", has gained over thirty million users.
With App Engine, Google has released the first public API to BigTable, its planetary datastore, which performs successfully at petabyte scale across diverse applications from search to finance to Google Earth.
This presentation will cover App Engine's features and limitations, and how to exploit this new and evolving platform.
This document discusses PageSpeed, a tool for just-in-time performance optimization of web pages. It provides automatic image compression and resizing, CSS and JavaScript minification, inline small files, caching, and deferring JavaScript among other optimizations. While most performance issues are well understood, not all websites are fast due to the tradeoff between speed and ease of maintenance. PageSpeed tools like mod_pagespeed can automate optimizations to improve performance without extra work from developers.
Metrics, metrics everywhere (but where the heck do you start?) SOASTA
This document discusses various metrics for measuring website performance and user experience. It outlines different types of metrics including:
- Network metrics like DNS resolution, TCP connection times, and time to first byte.
- Browser metrics like start render time, DOM loading/ready times, and page load times.
- Resource-level metrics obtained from the Resource Timing API like individual asset load times and response sizes.
- User-centric metrics like Speed Index, time to visible content, and metrics for single-page applications without traditional page loads.
It emphasizes the importance of measuring real user monitoring data alongside synthetic tests, and looking at higher percentiles rather than just averages due to variability in user environments and network conditions
Velocity NYC: Metrics, metrics everywhere (but where the heck do you start?)Cliff Crocker
This document discusses various metrics for measuring website performance. It begins by noting that there are many metrics to consider and no single metric tells the whole story. It then discusses several key metrics for measuring different aspects of performance, including:
- Front-end metrics like start render, DOM loading/ready, and page load that can isolate front-end from back-end performance.
- Network metrics like DNS and TCP timings that provide insight into connectivity issues.
- Resource timing metrics that measure individual assets to understand impacts of third parties and CDNs.
- User timing metrics like measuring above-the-fold content that capture user experience.
It emphasizes the importance of considering real user monitoring data alongside
Metrics, metrics everywhere (but where the heck do you start?)Tammy Everts
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.
Why is this ASP.NET web app running slowly?Mark Friedman
This presentation attempts to make assumptions used in popular web performance tools like YSlow and webpagetest explicit. It also looks at the NavTiming API and explores ways to capture RUM measurements and correlate them with server-side metrics.
It is all about a huge knowledge chasm created by a few years out of practical programming and especially without experiencing web programming. This speech is about many of us that have knowledge of programming other technologies and have to face a new challenge, in this case: developing a web application.
This document discusses modern web applications using progressive web apps (PWA) and WebAssembly (WASM). It begins by defining a web application and describing challenges like performance issues. It then introduces PWAs and WASM as solutions, explaining what they are, how they work, and providing examples. The document shares links to starter kits and success stories to help readers get started with building modern web apps using these technologies.
The document discusses user experience management and outlines various web performance metrics that can be captured from browsers such as time-to-first-byte, onload time, bandwidth, rendering time, and resource download times. It describes the W3C Navigation Timing and Resource Timing APIs that browsers expose to capture this performance data non-intrusively. Examples are provided of how this data could be used for real-world applications like identifying geo hotspots, page error monitoring, and performance profiling.
Monitoring web application response times^lj a hybrid approach for windowsMark Friedman
This document discusses web application performance monitoring and summarization. It covers tools like YSlow for analyzing page load times, and introduces an approach using Event Tracing for Windows (ETW) to capture performance data from web applications. This includes intercepting Yahoo Boomerang beacon requests to generate ETW events with page load time measurements and other data for analysis. A Web Application Trace Explorer is demonstrated to filter and report on these events to help explore server-side event streams and web application performance.
Performance is the most important attribute for success of any commercial and Enterprise Software. In a client server environment, developers focus a lot on optimizing the Data and Logical Tiers. Optimization of Presentation Tier which is responsible for more than 30 % of performance is usually ignored.
The document is developed with the intension to teach the technical staff on Optimizing the Presentation Tier which significantly improves the performance of the Client Server applications.
Sherlock Homepage - A detective story about running large web services - NDC ...Maarten Balliauw
The site was slow. CPU and memory usage everywhere! Some dead objects in the corner. Something terrible must have happened! We have some IIS logs. Some traces from a witness. But not enough to find out what was wrong. In this session, we’ll see how effective telemetry, a profiler or two as well as a refresher of how IIS runs our ASP.NET web applications can help solve this server murder mystery.
Introduction to JQuery, ASP.NET MVC and SilverlightPeter Gfader
This document provides an overview of a presentation on jQuery, ASP.NET MVC, and Silverlight. It discusses jQuery being a lightweight JavaScript library that makes web development simpler. ASP.NET MVC is presented as an alternative to WebForms that separates concerns into models, views, and controllers. Silverlight is introduced as a technology for building rich interactive applications for the web using .NET.
Sherlock Homepage - A detective story about running large web services - WebN...Maarten Balliauw
The site was slow. CPU and memory usage everywhere! Some dead objects in the corner. Something terrible must have happened! We have some IIS logs. Some traces from a witness. But not enough to find out what was wrong. In this session, we’ll see how effective telemetry, a profiler or two as well as a refresher of how IIS runs our ASP.NET web applications can help solve this server murder mystery.
The site was slow. CPU and memory usage everywhere! Some dead objects in the corner. Something terrible must have happened! We have some IIS logs. Some traces from a witness. But not enough to find out what was wrong. In this session, we’ll see how effective telemetry, a profiler or two as well as a refresher of how IIS runs our ASP.NET web applications can help solve this server murder mystery.
Sherlock Homepage - A detective story about running large web services (VISUG...Maarten Balliauw
The site was slow. CPU and memory usage everywhere! Some dead objects in the corner. Something terrible must have happened! We have some IIS logs. Some traces from a witness. But not enough to find out what was wrong. In this session, we’ll see how effective telemetry, a profiler or two as well as a refresher of how IIS runs our ASP.NET web applications can help solve this server murder mystery.
Cloud APIs provide programmatic access to cloud resources and services. They allow developers to interact with applications, development environments, and raw compute/storage resources through standardized interfaces. While each cloud provider currently has their own proprietary APIs, there is a push for open standards to accelerate development of higher-level services and commoditization of basic resources. Key areas for a common cloud API include resource representations, security requirements, and orchestration of ensembles of resources across providers.
Stardust is a mature, industry-proven business process management suite that is now available as an open source project under the Eclipse Public License. It includes capabilities for workflow, system integration, and document management. Stardust has seen production deployments with over 10,000 users, 1,000,000 processes per day, and 300,000 documents per day. The codebase consists of over 3 million lines of code and 200 third-party libraries. The Stardust community is actively enhancing the knowledge base and collaborating with other projects.
This document discusses how HTML5 can be used to build engaging mobile applications. Key features covered include offline storage using the Application Cache API, storing data locally using Web Storage, using a SQL database with Web SQL, advanced graphics capabilities with Canvas and SVG, real-time communications over WebSockets, and tools for developing HTML5 apps like jQuery Mobile, Sencha Touch, and Google Web Toolkit. It emphasizes testing on multiple platforms and browsers to ensure compatibility.
Metrics, metrics everywhere (but where the heck do you start?)Tammy Everts
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.
Metrics, Metrics Everywhere (but where the heck do you start?)SOASTA
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.
Metrics, Metrics Everywhere (but where the heck do you start?)SOASTA
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.
Similar to Make It Fast - Using Modern Browser Performance APIs to Monitor and Improve the Performance of your Web Apps (20)
What is a “modern” metric anyway? An exploration on how to measure and evaluate popular (and experimental) web performance metrics, and how they affect user happiness and business goals.
We'll talk about how data can be biased, and how best to interpret performance data given those biases. We'll look at a broad set of RUM data we've captured to see how the Core Web Vitals correlate (or not) to other performance and business metrics. Finally, we'll share a new way that others can research modern metrics and RUM data.
Check Yourself Before You Wreck Yourself: Auditing and Improving the Performa...Nicholas Jansma
Boomerang is an open-source Real User Monitoring (RUM) JavaScript library used by thousands of websites to measure their visitor's experiences. The developers behind Boomerang take pride in building a reliable and performant third-party library that everyone can use without being concerned about its measurements affecting their site. We recently performed and shared an audit of Boomerang's performance, to help communicate its "cost of doing business", and in doing so we found several areas of code that we wanted to improve. We'll discuss how we performed the audit, some of the improvements we've made, how we're testing and validating our changes, and the real-time telemetry we capture for our library to ensure we're having as little of an impact as possible on the sites we're included on.
Boomerang is an open-source Real User Monitoring (RUM) JavaScript library used by thousands of websites to measure their visitor's experiences.
Boomerang runs on billions of page loads a day, either via the open-source library or as part of Akamai's mPulse RUM service. The developers behind Boomerang take pride in building a reliable and performant third-party library that everyone can use without being concerned about its measurements affecting their site.
Recently, we performed and shared an audit of Boomerang's performance, to help communicate the "cost of doing business" of including Boomerang on a page while it takes its measurements. In doing the audit, we found several areas of code that we wanted to improve and have been making continuous improvements ever since. We've taken ideas and contributions from the OSS community, and have built a Performance Lab that helps "lock in" our improvements by continuously measuring the metrics that are important to us.
We'll discuss how we performed the audit, some of the improvements we've made, how we're testing and validating our changes, and the real-time telemetry we capture on our library to ensure we're having as little of an impact as possible on the sites we're included on.
When Third Parties Stop Being Polite... and Start Getting RealNicholas Jansma
By Nic Jansma and Charlie Vazac (Akamai)
Fluent 2018
Would you give the Amazon Prime delivery robot the key to your house, just because it stops by to deliver delicious packages every day? Even if you would, do you still have 100% confidence that it wouldn’t accidentally drag in some mud, let the neighbor in, steal your things, or burn your house down? Worst-case scenarios such as these are what you should be planning for when deciding whether or not to include third-party libraries and services on your website. While most libraries have good intentions, by including them on your site, you have given them complete control over the kingdom. Once on your site, they can provide all of the great services you want—or they can destroy everything you’ve worked so hard to build.
It’s prudent to be cautious: we’ve all heard stories about how third-party libraries have caused slowdowns, broken websites, and even led to downtime. But how do you evaluate the actual costs and potential risks of a third-party library so you can balance that against the service it provides? Every library requires nonzero overhead to provide the service it claims. In many cases, the overhead is minimal and justified, but we should quantify it to understand the real cost. In addition, libraries need to be carefully crafted so they can avoid causing additional pain when the stars don’t align and things go wrong.
Nic Jansma and Charles Vazac perform an honest audit of several popular third-party libraries to understand their true cost to your site, exploring loading patterns, SPOF avoidance, JavaScript parsing, long tasks, runtime overhead, polyfill headaches, security and privacy concerns, and more. From how the library is loaded, to the moment it phones home, you’ll see how third-parties can affect the host page and discover best practices you can follow to ensure they do the least potential harm.
With all of the great performance tools available to developers today, we’ve gained a lot of insight into just how much third-party libraries are impacting our websites. Nic and Charles detail tools to help you decide if a library’s risks and unseen costs are worth it. While you may not have the time to perform a deep dive into every third-party library you want to include on your site, you’ll leave with a checklist of the most important best practices third-parties should be following for you to have confidence in them.
Responsiveness to user interaction is crucial for users of web apps, and businesses need to be able to measure responsiveness so they can be confident that their users are happy. Unfortunately, users are regularly bogged down by frustrations such as a delayed "time to interactive” during page load, high or variable input latency on critical interaction events (tap, click, scroll, etc.), and janky animations or scrolling. These negative experiences turn away visitors, affecting the bottom line. Sites that include third-party content (ads, social plugins, etc.) are frequently the worst offenders.
The culprit behind all these responsiveness issues are “long tasks," which monopolize the UI thread for extended periods and block other critical tasks from executing. Developers lack the necessary APIs and tools to measure and gain insight into such problems in the wild and are essentially flying blind trying to figure out what the main offenders are. While developers are able to measure some aspects of responsiveness, it’s often not in a reliable, performant, or “good citizen” way, and it’s near impossible to correctly identify the perpetrators.
Shubhie Panicker and Nic Jansma share new web performance APIs that enable developers to reliably measure responsiveness and correctly identify first- and third-party culprits for bad experiences. Shubhie and Nic dive into real-user measurement (RUM) web performance APIs they have developed: standardized web platform APIs such as Long Tasks as well as JavaScript APIs that build atop platform APIs, such as Time To Interactive. Shubhie and Nic then compare these measurements to business metrics using real-world data and demonstrate how web developers can detect issues and reliably measure responsiveness in the wild—both at page load and postload—and thwart the culprits, showing you how to gather the data you need to hold your third-party scripts accountable.
Measuring Real User Performance in the BrowserNicholas Jansma
To people responsible for the health of web properties, monitoring, measurement, and analysis of real-user experiences is key to delivering a consistent and delightful experience. Drawing on their experience with the open source boomerang project, Philip Tellis and Nic Jansma explore various tools and methods available to measure real-user performance in the browser.
Topics include:
Available browser APIs: Navigation Timing, Resource Timing (Levels 1 and 2), User Timing, Error Logging, and more
Measuring full-page apps
Measuring single-page apps
RUM SpeedIndex
Measuring continuity
Hacks when an API isn’t available
Avoiding the observer effect
Filtering data to get rid of noise
Identifying outliers and treating them differently
Measuring the Performance of Single Page ApplicationsNicholas Jansma
Single page applications are a problem for RUM tools because there are no easy ways to tell when a new page component has been requested asynchronously as a result of an intentional user action. Many network requests are back-end service calls initiated periodically by the app – for example, a ping to check if content has been updated, or to check if the current user should still be signed in to their account.
Even with requests that are initiated by a user action, not all may fit into the definition of a “page view.” For example, a user typing into a search box that has auto-complete capabilities will often result in network requests, but these requests result in very small amounts of data transfer, happen very frequently, and do not count toward page views. The scene is further complicated by SPA frameworks like Angular, Backbone, and others.
In this talk, we’ll learn about some of the tricks used by boomerang to measure the performance of single page applications, going as far as capturing errors and waterfall information across browsers.
This document discusses JavaScript module patterns, which help organize and limit the scope of code in projects. It covers different patterns for creating objects and modules, including using constructors, prototypes, the revealing module pattern, CommonJS, and AMD. The basic module pattern allows defining private and public members to encapsulate data and functions. Later patterns like CommonJS and AMD build on this to support asynchronous loading and use in different environments like the browser and Node.js.
Sails.js is a MVC web framework for Node.js built on Express. It is inspired by frameworks like Ruby on Rails and uses conventions over configurations. Sails.js features include a database-agnostic ORM, auto-generated REST APIs, and easy WebSocket integration. To get started, install Sails.js globally and use the sails command to generate a new project, lift the app, and generate models, controllers and REST APIs.
Appcelerator Titanium is a cross-platform development environment where you can build iOS, Android, BlackBerry and Hybrid/HTML5 apps. This talk will discuss how it works, how to get started, code samples and pros/cons from experience.
The Happy Path: Migration Strategies for Node.jsNicholas Jansma
The document outlines a strategy for migrating an existing ASP.NET MVC and MongoDB todo application to use Node.js. It proposes a 4 phase approach: 1) Build a Node.js API and integrate it with the Angular frontend, 2) Add an admin interface with real-time monitoring, 3) Allow horizontal scaling of Node instances, and 4) Fully migrate the existing ASP.NET MVC API to Node.js to see performance improvements. Each phase is demonstrated with code examples and a running prototype. The overall goal is to prototype new features faster using Node.js before committing to a full migration.
Phing is a PHP build tool, similar to Apache's Ant. Phing can be used for everything from validating your build, running tests, combining/minifying resources to deploying.
- Nic Jansma is a developer who previously worked at Microsoft and recently founded Wolverine Digital to develop high-performance websites and apps.
- He used Appcelerator Titanium to build cross-platform mobile apps, including a LEGO Minifigure catalog app, allowing him to write code once and deploy to both iOS and Android.
- While Titanium allowed cross-platform development, Nic still encountered platform-specific issues and the need to occasionally write platform-specific code, but found Titanium a good choice overall for his needs.
INDIAN AIR FORCE FIGHTER PLANES LIST.pdfjackson110191
These fighter aircraft have uses outside of traditional combat situations. They are essential in defending India's territorial integrity, averting dangers, and delivering aid to those in need during natural calamities. Additionally, the IAF improves its interoperability and fortifies international military alliances by working together and conducting joint exercises with other air forces.
Advanced Techniques for Cyber Security Analysis and Anomaly DetectionBert Blevins
Cybersecurity is a major concern in today's connected digital world. Threats to organizations are constantly evolving and have the potential to compromise sensitive information, disrupt operations, and lead to significant financial losses. Traditional cybersecurity techniques often fall short against modern attackers. Therefore, advanced techniques for cyber security analysis and anomaly detection are essential for protecting digital assets. This blog explores these cutting-edge methods, providing a comprehensive overview of their application and importance.
RPA In Healthcare Benefits, Use Case, Trend And Challenges 2024.pptxSynapseIndia
Your comprehensive guide to RPA in healthcare for 2024. Explore the benefits, use cases, and emerging trends of robotic process automation. Understand the challenges and prepare for the future of healthcare automation
Quality Patents: Patents That Stand the Test of TimeAurora Consulting
Is your patent a vanity piece of paper for your office wall? Or is it a reliable, defendable, assertable, property right? The difference is often quality.
Is your patent simply a transactional cost and a large pile of legal bills for your startup? Or is it a leverageable asset worthy of attracting precious investment dollars, worth its cost in multiples of valuation? The difference is often quality.
Is your patent application only good enough to get through the examination process? Or has it been crafted to stand the tests of time and varied audiences if you later need to assert that document against an infringer, find yourself litigating with it in an Article 3 Court at the hands of a judge and jury, God forbid, end up having to defend its validity at the PTAB, or even needing to use it to block pirated imports at the International Trade Commission? The difference is often quality.
Quality will be our focus for a good chunk of the remainder of this season. What goes into a quality patent, and where possible, how do you get it without breaking the bank?
** Episode Overview **
In this first episode of our quality series, Kristen Hansen and the panel discuss:
⦿ What do we mean when we say patent quality?
⦿ Why is patent quality important?
⦿ How to balance quality and budget
⦿ The importance of searching, continuations, and draftsperson domain expertise
⦿ Very practical tips, tricks, examples, and Kristen’s Musts for drafting quality applications
https://www.aurorapatents.com/patently-strategic-podcast.html
Measuring the Impact of Network Latency at TwitterScyllaDB
Widya Salim and Victor Ma will outline the causal impact analysis, framework, and key learnings used to quantify the impact of reducing Twitter's network latency.
Blockchain technology is transforming industries and reshaping the way we conduct business, manage data, and secure transactions. Whether you're new to blockchain or looking to deepen your knowledge, our guidebook, "Blockchain for Dummies", is your ultimate resource.
Implementations of Fused Deposition Modeling in real worldEmerging Tech
The presentation showcases the diverse real-world applications of Fused Deposition Modeling (FDM) across multiple industries:
1. **Manufacturing**: FDM is utilized in manufacturing for rapid prototyping, creating custom tools and fixtures, and producing functional end-use parts. Companies leverage its cost-effectiveness and flexibility to streamline production processes.
2. **Medical**: In the medical field, FDM is used to create patient-specific anatomical models, surgical guides, and prosthetics. Its ability to produce precise and biocompatible parts supports advancements in personalized healthcare solutions.
3. **Education**: FDM plays a crucial role in education by enabling students to learn about design and engineering through hands-on 3D printing projects. It promotes innovation and practical skill development in STEM disciplines.
4. **Science**: Researchers use FDM to prototype equipment for scientific experiments, build custom laboratory tools, and create models for visualization and testing purposes. It facilitates rapid iteration and customization in scientific endeavors.
5. **Automotive**: Automotive manufacturers employ FDM for prototyping vehicle components, tooling for assembly lines, and customized parts. It speeds up the design validation process and enhances efficiency in automotive engineering.
6. **Consumer Electronics**: FDM is utilized in consumer electronics for designing and prototyping product enclosures, casings, and internal components. It enables rapid iteration and customization to meet evolving consumer demands.
7. **Robotics**: Robotics engineers leverage FDM to prototype robot parts, create lightweight and durable components, and customize robot designs for specific applications. It supports innovation and optimization in robotic systems.
8. **Aerospace**: In aerospace, FDM is used to manufacture lightweight parts, complex geometries, and prototypes of aircraft components. It contributes to cost reduction, faster production cycles, and weight savings in aerospace engineering.
9. **Architecture**: Architects utilize FDM for creating detailed architectural models, prototypes of building components, and intricate designs. It aids in visualizing concepts, testing structural integrity, and communicating design ideas effectively.
Each industry example demonstrates how FDM enhances innovation, accelerates product development, and addresses specific challenges through advanced manufacturing capabilities.
Kief Morris rethinks the infrastructure code delivery lifecycle, advocating for a shift towards composable infrastructure systems. We should shift to designing around deployable components rather than code modules, use more useful levels of abstraction, and drive design and deployment from applications rather than bottom-up, monolithic architecture and delivery.
UiPath Community Day Kraków: Devs4Devs ConferenceUiPathCommunity
We are honored to launch and host this event for our UiPath Polish Community, with the help of our partners - Proservartner!
We certainly hope we have managed to spike your interest in the subjects to be presented and the incredible networking opportunities at hand, too!
Check out our proposed agenda below 👇👇
08:30 ☕ Welcome coffee (30')
09:00 Opening note/ Intro to UiPath Community (10')
Cristina Vidu, Global Manager, Marketing Community @UiPath
Dawid Kot, Digital Transformation Lead @Proservartner
09:10 Cloud migration - Proservartner & DOVISTA case study (30')
Marcin Drozdowski, Automation CoE Manager @DOVISTA
Pawel Kamiński, RPA developer @DOVISTA
Mikolaj Zielinski, UiPath MVP, Senior Solutions Engineer @Proservartner
09:40 From bottlenecks to breakthroughs: Citizen Development in action (25')
Pawel Poplawski, Director, Improvement and Automation @McCormick & Company
Michał Cieślak, Senior Manager, Automation Programs @McCormick & Company
10:05 Next-level bots: API integration in UiPath Studio (30')
Mikolaj Zielinski, UiPath MVP, Senior Solutions Engineer @Proservartner
10:35 ☕ Coffee Break (15')
10:50 Document Understanding with my RPA Companion (45')
Ewa Gruszka, Enterprise Sales Specialist, AI & ML @UiPath
11:35 Power up your Robots: GenAI and GPT in REFramework (45')
Krzysztof Karaszewski, Global RPA Product Manager
12:20 🍕 Lunch Break (1hr)
13:20 From Concept to Quality: UiPath Test Suite for AI-powered Knowledge Bots (30')
Kamil Miśko, UiPath MVP, Senior RPA Developer @Zurich Insurance
13:50 Communications Mining - focus on AI capabilities (30')
Thomasz Wierzbicki, Business Analyst @Office Samurai
14:20 Polish MVP panel: Insights on MVP award achievements and career profiling
Are you interested in dipping your toes in the cloud native observability waters, but as an engineer you are not sure where to get started with tracing problems through your microservices and application landscapes on Kubernetes? Then this is the session for you, where we take you on your first steps in an active open-source project that offers a buffet of languages, challenges, and opportunities for getting started with telemetry data.
The project is called openTelemetry, but before diving into the specifics, we’ll start with de-mystifying key concepts and terms such as observability, telemetry, instrumentation, cardinality, percentile to lay a foundation. After understanding the nuts and bolts of observability and distributed traces, we’ll explore the openTelemetry community; its Special Interest Groups (SIGs), repositories, and how to become not only an end-user, but possibly a contributor.We will wrap up with an overview of the components in this project, such as the Collector, the OpenTelemetry protocol (OTLP), its APIs, and its SDKs.
Attendees will leave with an understanding of key observability concepts, become grounded in distributed tracing terminology, be aware of the components of openTelemetry, and know how to take their first steps to an open-source contribution!
Key Takeaways: Open source, vendor neutral instrumentation is an exciting new reality as the industry standardizes on openTelemetry for observability. OpenTelemetry is on a mission to enable effective observability by making high-quality, portable telemetry ubiquitous. The world of observability and monitoring today has a steep learning curve and in order to achieve ubiquity, the project would benefit from growing our contributor community.
論文紹介:A Systematic Survey of Prompt Engineering on Vision-Language Foundation ...Toru Tamaki
Jindong Gu, Zhen Han, Shuo Chen, Ahmad Beirami, Bailan He, Gengyuan Zhang, Ruotong Liao, Yao Qin, Volker Tresp, Philip Torr "A Systematic Survey of Prompt Engineering on Vision-Language Foundation Models" arXiv2023
https://arxiv.org/abs/2307.12980
TrustArc Webinar - 2024 Data Privacy Trends: A Mid-Year Check-InTrustArc
Six months into 2024, and it is clear the privacy ecosystem takes no days off!! Regulators continue to implement and enforce new regulations, businesses strive to meet requirements, and technology advances like AI have privacy professionals scratching their heads about managing risk.
What can we learn about the first six months of data privacy trends and events in 2024? How should this inform your privacy program management for the rest of the year?
Join TrustArc, Goodwin, and Snyk privacy experts as they discuss the changes we’ve seen in the first half of 2024 and gain insight into the concrete, actionable steps you can take to up-level your privacy program in the second half of the year.
This webinar will review:
- Key changes to privacy regulations in 2024
- Key themes in privacy and data governance in 2024
- How to maximize your privacy program in the second half of 2024
6. BUT...
Measuring performance from the server and developer
perspective is not the full story
The only thing that really matters is what your end-user
sees
Measuring real-world performance of your end-users is
tough
8. W3C WEBPERF WORKING
GROUP
www.w3.org/2010/webperf
Founded 2010 to give developers the ability to assess and
understand performance characteristics of their web apps
The mission of the Web Performance Working Group is to
provide methods to measure aspects of application
performance of user agent features and APIs
Microsoft, Google, Mozilla, Opera, Facebook, Netflix, etc
9. WORKING GROUP GOALS
Expose information that was not previously available
Give developers the tools they need to make their
applications more efficient
Little to no overhead
Easy to understand APIs
10. PUBLISHED SPECS
Navigation Timing (NT): Page load timings
Resource Timing (RT): Resource load timings
User Timing (UT): Custom site events and measurements
Performance Timeline: Access NT/RT/UT and future
timings from one API
High Resolution Time: Better Date.now()
11. PUBLISHED SPECS (PT 2)
Page Visibility: Visibility state of document
Timing control for script-based animations:
requestAnimationFrame()
Efficient Script Yielding: More efficient than
setTimeout(...,0): setImmediate()
12. UPCOMING SPECS
Beacon: Async send data (even after page is closed)
Resource Hints: rel="preconnect" rel="preload"
Resource Priorities: lazyload
Frame Timing: Animation timings
Navigation Error Logging: For failed navigations
15. HOW IT WAS DONE
BEFORE
(this isn't accurate)
<html><head><script>
varstart=newDate().getTime();
functiononLoad{
varpageLoadTime=(newDate().getTime())-start;
}
body.addEventListener(“load”,onLoad,false);
</script>...</html>
16. WHAT'S WRONG WITH
THIS?
It only measures the time from when the HTML gets
parsed to when the last sub-resource is downloaded
It misses the initial DNS lookup, TCP connection and HTTP
request wait time
Date().getTime()is not reliable
17. INTERLUDE
DOMHighResTimeStamp
Date DOMHighResTimeStamp
Accessed Via Date().getTime()performance.now()
Resolution millisecond sub-millisecond
Start Unix epoch navigationStart
Monotonically
Non-
decreasing
No Yes
Affected by
user's clock
Yes No
Example 1420147524606 3392.275999998674
22. THEN WHAT?
DIY / Open Source
Send this data to your backend for logging
Show any page's timings via a bookmarklet:
Boomerang:
Boomcatch:
BoomerangExpress:
SiteSpeed.io:
Piwik:
kaaes.github.io/timing
github.com/lognormal/boomerang
cruft.io/posts/introducing-boomcatch
github.com/andreas-
marschke/boomerang-express
www.sitespeed.io
github.com/piwik/piwik
36. TIPS
Use fetchStartinstead of navigationStartunless
you're interested in redirects, tab init time, etc
loadEventEndwill be 0 until after the body's loadevent
has finished (so you can't measure it in the loadevent)
We don't have an accurate way to measure the "request
time", as "requestEnd" is invisible to us (the server sees
it)
secureConnectionStartisn't available in IE
38. TIPS (PT 2)
iOS still doesn't have support
Home page scenarios: Timestamps up through
responseEndevent may be 0 duration because some
browsers speculatively pre-fetch home pages (and don't
report the correct timings)
If possbile, do any beaconing of the data as soon as
possible. Browser onbeforeunloadisn't 100% reliable
for sending data
Single-Page Apps: You'll need a different solution for
"navigations" (Boomerang + plugin coming soon)
42. HOW IT WAS DONE
BEFORE
For dynamically inserted content, you could time how long it
took from DOM insertion to the element’s onLoad event
43. HOW IT WAS DONE
BEFORE
(this isn't practical for all content)
varstart=newDate().getTime();
varimage1=newImage();
varresourceTiming=function(){
varnow=newDate().getTime();
varlatency=now-start;
alert("Endtoendresourcefetch:"+latency);
};
image1.onload=resourceTiming;
image1.src='http://www.w3.org/Icons/w3c_main.png';
44. WHAT'S WRONG WITH
THIS?
It measures end-to-end download time plus rendering
time
Not practical if you want to measure every resource on
the page (IMG, SCRIPT, LINK rel="css", etc)
Date().getTime()is not reliable
47. PERFORMANCETIMELINE
window.performance
getEntries(): Gets all entries in the timeline
getEntriesByType(type): Gets all entries of the
specified type (eg resource, mark, measure)
getEntriesByName(name): Gets all entries with the
specified name (eg URL or mark name)
51. USE CASES
Send all resource timings to your backend analytics
Raise an analytics event if any resource takes over X
seconds to download (and trend this data)
Watch specific resources (eg third-party ads or analytics)
and complain if they are slow
52. BUFFER
There is a ResourceTiming buffer (per IFRAME) that stops
filling after its size limit is reached (default: 150 entries)
Listen for the onresourcetimingbufferfullevent
setResourceTimingBufferSize(n)and
clearResourceTimings()can be used to modify it
Don't just:
setResourceTimingBufferSize(99999999)as this
can lead to browser memory growing unbound
53. COMPRESSING
Each resource is ~ 500 bytes JSON.stringify()'d
tells us there's 99 HTTP resources on
average, per page, with an average URL length of 85 bytes
That means you could expect around 45 KB of
ResourceTiming data per page load
Compress it:
HTTP Archive
nicj.net/compressing-resourcetiming
56. TIMING-ALLOW-ORIGIN
By default, cross-origin resources expose timestamps for
only the fetchStartand responseEndattributes
This is to protect your privacy (attacker can’t load random
URLs to see where you’ve been)
Override by setting Timing-Allow-Originheader
Timing-Allow-Origin = "Timing-Allow-Origin"
":" origin-list-or-null | "*"
If you have a CDN, use this
Note: Third-party libraries (ads, analytics, etc) must set
this on their servers. 5% do according to HTTP Archive.
Google, Facebook, Disqus, mPulse, etc.
57. BLOCKING TIME
Browsers will open a limited number of connections to
each unique origin (protocol/server name/port)
If there are more resources than the # of connections, the
later resources will be "blocking", waiting for their turn to
download
durationincludes Blocking time!
So in general, don't use duration, but this is all you get
with cross-origin resources.
59. DIY / OPEN SOURCE
Compress + send this data to your backend for logging
Show any page's resources via a bookmarklet:
Heatmap bookmarklet / Chrome extension:
Nurun's Performance Bookmarklet:
Boomerang supports ResourceTiming:
github.com/andydavies/waterfall
github.com/zeman/perfmap
github.com/nurun/performance-bookmarklet
github.com/lognormal/boomerang
68. TIPS
For many sites, most of your content will not be same-
origin, so ensure all of your CDNs and third-party libraries
send Timing-Allow-Origin
What isn't included in ResourceTiming:
The root HTML page (get this from
window.performance.timing)
Transfer size or content size (privacy concerns)
HTTP code (privacy concerns)
Content that loaded with errors (eg 404s)
69. TIPS (PT 2)
If you're going to be managing the ResourceTiming buffer,
make sure no other scripts are managing it as well
The durationattribute includes Blocking time (when a
resource is behind other resources on the same socket)
Each IFRAMEwill have its own ResourceTiming data, and
those resources won't be included in the parent
FRAME/document. So you'll need to traverse the
document frames to get all resources. See
for
an example
about:blank, javascript:URLs will be seen in RT data
github.com/nicjansma/resourcetiming-compression.js
74. HOW TO USE - MARK
//mark
performance.mark("start");
performance.mark("end");
performance.mark("another");
performance.mark("another");
performance.mark("another");
75. HOW TO USE - MARK
//retrieve
performance.getEntriesByType("mark");
[
{
"duration":0,
"startTime":150384.48100000096,
"entryType":"mark",
"name":"start"
},
{
"duration":0,
"startTime":150600.5250000013,
"entryType":"mark",
"name":"end"
},
...
]
76. HOW TO USE - MEASURE
//measure
performance.mark("start");
//dowork
performance.mark("start2");
//measurefrom"now"tothe"start"mark
performance.measure("timetodostuff","start");
//measurefrom"start2"tothe"start"mark
performance.measure("timefromstarttostart2","start","start2");
77. HOW TO USE - MEASURE
//retrieval-specific
performance.getEntriesByName("timefromstarttostart2","measure");
[
{
"duration":4809.890999997151,
"startTime":145287.66500000347,
"entryType":"measure",
"name":"timefromstarttostart2"
}
]
78. BENEFITS
Uses the PerformanceTimeline, so marksand
measuresare in the PerformanceTimeline along with
other events
Uses DOMHighResTimestampinstead of Dateso sub-
millisecond, monotonically non-decreasing, etc
More efficient, as the native browser runtime can do math
quicker and store things more performantly than your
JavaScript runtime can
79. USE CASES
Easy way to add profiling events to your application
Note important scenario durations in your Performance
Timeline
Measure important durations for analytics
Browser tools are starting to add support for showing
these
81. USERTIMING.JS
Polyfill that adds UserTiming support to browsers that do
not natively support it.
UserTiming is accessed via the PerformanceTimeline, and
requires window.performance.now() support, so
UserTiming.js adds a limited version of these interfaces if
the browser does not support them
github.com/nicjansma/usertiming.js
82. DIY / OPEN SOURCE
Compress + send this data to your backend for logging
WebPageTest sends UserTiming to Google Analytics,
Boomerang and SOASTA mPulse