This document summarizes a presentation on high performance mobile web. The presentation covers:
- Delivering fast mobile experiences by making fewer HTTP requests, using CDNs, browser prefetching, and other techniques.
- Measuring web performance using Navigation Timing, Resource Timing, custom timing marks, and tools like WebPagetest and Google Analytics.
- Typical mobile network performance statistics like average latency, download speeds, and how these numbers impact page load times.
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.
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.
This document discusses using HAProxy as a load balancer and discusses its benefits and uses. It describes how HAProxy can be used to make non-highly available services highly available and provide load balancing. It also discusses ways to address potential single points of failure with HAProxy, such as using Corosync and Pacemaker to set up redundant HAProxy clusters. Upstream failures from slow databases or application servers are also addressed.
A web perf dashboard up & running in 90 minutes presentationJustin Dorfman
A Web Performance Dashboard can be set up and running in 90 minutes using freely available tools. The summary collects performance data from real users using boomerang.js and synthetic data from WebPagetest. The data is processed and stored using StatsD and Graphite. Finally, the dashboard is built by pulling the data into Piwik for visualization and monitoring.
Using Modern Browser APIs to Improve the Performance of Your Web ApplicationsNicholas Jansma
This document discusses modern browser APIs that can improve web application performance. It covers Navigation Timing, Resource Timing, and User Timing which provide standardized ways to measure page load times, resource load times, and custom events. Other APIs discussed include the Performance Timeline, Page Visibility, requestAnimationFrame for script animations, High Resolution Time for more precise timestamps, and setImmediate for more efficient script yielding than setTimeout. These browser APIs give developers tools to assess and optimize the performance of their applications.
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.
Front-End Single Point of Failure - Velocity 2016 TrainingPatrick Meenan
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.
HAProxy is an open source load balancer that can distribute traffic across multiple servers. It can balance both TCP and HTTP-based applications. It is lightweight, widely used, and has features like load balancing algorithms, health checks, failover, and logging. The configuration file haproxy.cfg contains sections for global settings, defaults, listening ports, frontends, and backends to configure load balancing across server pools.
This document discusses using NGINX to deliver high performance applications through efficient caching. It explains that NGINX can be used as a web server, load balancer, and high availability content cache to provide low latency, scalability, availability and reduced costs. Specific NGINX caching configurations like proxy_cache, proxy_cache_valid and proxy_cache_background_update are described. Microcaching optimizations with NGINX are also covered, showing significant performance improvements over Apache+WordPress and a reverse proxy only setup.
The document provides biographical information about Brandon Kang in Korean. It lists his previous work experiences at Samsung SDS and Microsoft Korea, as well as his current role at Akamai Korea. It also outlines his areas of focus, which include writing books and translating on topics such as IT trends, web programming, mobile apps, and games.
The document summarizes load balancing at Tuenti using HAProxy. It describes how Tuenti moved from using Linux boxes with LVS and ldirectord for load balancing to using HAProxy for its improved layer 7 capabilities. The new setup uses HAProxy for SSL termination on 4 load balancers behind which are over 500 frontend servers. HAProxy allows for health checks, persistence, content routing, monitoring and other advanced load balancing features.
5 steps to faster web sites & HTML5 games - updated for DDDscotMichael Ewins
5 practical steps we have taken to improve page loading for web sites and HTML5 games.
1. Fewer requests
2. Smaller resources
3. Reduce the round trip time
4. Optimise the critical rendering path
5. Educate the whole team about performance
Grafana is not enough: DIY user interfaces for PrometheusWeaveworks
This talk gives a quick overview of the currently available Prometheus UIs and shows ways to build your own interfaces to enable your workflows. Most popular among the UIs is Grafana, which works well with Prometheus and is lovely for dashboarding, but terrible for troubleshooting. What do you do if you want to slightly modify queries based on your dashboards? How can you explore the keys and values of your metric labels quickly? Having trouble remembering PromQL syntax? This talk presents small building UI blocks to get to your results faster and save the day.
5 Steps to Faster Web Sites and HTML5 GamesMichael Ewins
This document discusses many techniques for optimizing website performance and speed. It provides tips for reducing page load time by minimizing requests, compressing files, leveraging caching, prioritizing critical resources, and establishing a culture of performance within a development team. Specific recommendations include concatenating and minifying scripts and CSS, optimizing images, enabling browser caching, reducing redirects and unnecessary requests, and pre-rendering content for initial views.
This is a presentation made at the Burlington, Vermont PHP Users Group about configuring load balancing using the Apache HTTP Server. Load balancing is a technique that can distribute work across multiple server nodes—here we will discuss load balancing HTTP (i.e. web) traffic. There are many software and hardware load balancing options available including HAProxy, Varnish, Pound, Perlbal, Squid, nginx, and Linux-HA (High-Availability Linux) on Linux Standard Base (LSB). However, many web developers are already familiar with Apache as a web server and it is relatively easy to also configure Apache as a load balancer.
Related concepts such as shared nothing architecture are discussed. We also take a look at some basic load balancing scenarios and features including sticky sessions and proxying requests based on HTTP method. Distributed load testing with Tsung is briefly discussed as well.
This document discusses using WebSockets for bidirectional communication between a GWT client and server. It provides an overview of setting up WebSocket connections on both the client and server sides in GWT, including writing a JSNI wrapper to initialize the WebSocket on the client. It also discusses using GWT's existing RPC serialization mechanism to serialize and deserialize Java objects sent over the WebSocket connection, avoiding the need for additional serialization libraries. Code examples are provided for initializing the WebSocket and handling messages on both the client and server sides, as well as using GWT's serialization streams to serialize and deserialize objects between the client and server.
HAProxy, the world’s fastest and most widely-used software load balancer, was first released in December 2001. The load balancer landscape has changed significantly since then. Yet HAProxy, with 17 years of active development under its belt, has continued to evolve and innovate. Now, we're announcing the release of HAProxy 1.9.
HTTP 1.1, which is the backbone of pretty much everything we’ve been using on the Internet, has been around for over 15 years. Recently the HTTP 2.0 specification has been completed and gradually application servers will start supporting it. It does make one wonder though: why change if something has been working for so long. In this talk we’ll examine the shortcomings of HTTP 1.1 and how 2.0 intends to address those. We’ll see what we need to know and how it’s going to affect our existing applications, and future ones.
Web Performance in the Age of HTTP/2 - FEDay Conference, Guangzhou, China 19/...Holger Bartel
Web performance optimisation has been gaining ground and is slowly getting more of its deserved recognition. Now that we’ve learned to recognise this integral part of user experience and are approaching HTTP/2 as our new protocol of choice, some of our existing web performance best practices will turn into the new anti-patterns.
Talk slides from FEDay Conference in Guangzhou, China on 19/03/2016.
Uber mobility - High Performance NetworkingDhaval Patel
Speakers: Ganesh Srinivasan & Minh Pham (Uber), Jim Roskind (Neumob), Makarand Dharmapurikar & Eric Anderson (Google), and Karthik Ramgopal (LinkedIn)
Networking is one of the most important, yet often underserved aspects of any mobile application. The latency and bandwidth of mobile networks can vary greatly between cities and even within cities, ranging from broadband LTE speeds to performance that feels more like a 300 baud modem.
You can read more about Uber Mobility here : https://www.uber.com/p/uber-mobility/
The document discusses optimizing browser experience with a focus on mobile performance. It notes that page load speed and frame rate affect user engagement. Some key challenges for mobile include higher latency, touch input latency, and limited battery life. It provides tips for faster initial rendering, such as inline critical resources and lazy loading others. It also recommends tools for measuring performance, such as Pagespeed Insights, Webpagetest, and the DevTools timeline. Maintaining 60 frames per second is important for smooth interactions, requiring optimizations like smaller DOM changes and using requestAnimationFrame. The document demonstrates DevTools frames and layers panels.
Art and Science of Web Sites Performance: A Front-end ApproachJiang Zhu
People love fast web sites, but up until now developers have been focusing on the wrong area. Network (TCP, buffers, routing) performance and Backend (web server, database, etc.) performance are important for reducing hardware costs and improving efficiency, but for most pages 80% of the load time is spent on the frontend (HTML, CSS, JavaScript, images, iframes, and others). We will talk about the best practices for making web pages faster, provide case study from top web site, and introduce the tools we use for researching performance. In addition to know how to improve web performance, we will also try to gain an understanding of the fundamentals of how the Internet works including DNS, HTTP, and browsers. This talks was given as an Educational Series called Fog Computing Reading Group at Cisco Advanced Architecture and Research. The content is derived from the materials by Steven Sounders (Google/Stanford), Collin Jackson (Stanford/CMU) and Daniel Austin (eBay).
A content delivery network (CDN) distributes content across multiple servers located around the world. This allows content to be served from servers closest to users, reducing latency and improving page load times. CDNs can increase website performance and reduce load on origin servers. They provide redundancy so if one server fails, users are redirected to another. Popular CDN providers include Akamai, Cloudflare, and Amazon Cloudfront.
This document provides an overview and agenda for a Janet Tech 2 Tech session on network performance. It discusses challenges in achieving optimal network performance, tools for troubleshooting issues like congestion and packet loss, best practices like implementing a Science DMZ, and Janet-hosted test tools including perfSONAR, iperf3, and a data transfer node for file transfers. The session aims to help members make the most of their Janet network connection and minimize data shipped by hard disk.
(BDT318) How Netflix Handles Up To 8 Million Events Per SecondAmazon Web Services
In this session, Netflix provides an overview of Keystone, their new data pipeline. The session covers how Netflix migrated from Suro to Keystone, including the reasons behind the transition and the challenges of zero loss while processing over 400 billion events daily. The session covers in detail how they deploy, operate, and scale Kafka, Samza, Docker, and Apache Mesos in AWS to manage 8 million events & 17 GB per second during peak.
This document discusses optimizing mobile networks and applications for speed. It begins with an overview of networking basics and how mobile networks work. It then discusses factors that affect speed like latency, bandwidth, TCP protocols, and cellular network routing. The document provides recommendations for optimizing like leveraging WiFi, anticipating latency, saving bandwidth and battery. It also covers HTTP optimizations, browser APIs and protocols like XHR, SSE and WebSockets. The goal is to understand how networks impact applications and how to design for optimal mobile performance.
Giving and introduction to the site speed topic and talking about the limiting factors of site-speed, how site-speed can me measured and monitored, how site-speed can be connected to business metrics and finally about typical site speed optimizations.
This document discusses ways to measure and improve web performance. It provides an overview of common web performance metrics and best practices, including minimizing HTTP requests, using content delivery networks, gzipping components, and reducing payload sizes. The document also introduces WebPageTest, an open-source tool for measuring page load performance that provides metrics on load times, waterfall charts, and TCP network traces. Finally, it discusses future opportunities to improve performance through technologies like HTTP/2 and continued optimization of images, scripts, and page weight.
Cloudflare lower network latency = faster website loadsVu Long Tran
Lower network latency = faster website loads
This document discusses how lower network latency leads to faster website loads. It explains that round-trip time (RTT) measures the time for a network request to travel from one point to another and back. Faster protocols like TLS 1.3 can reduce RTT by eliminating handshake rounds. Content delivery networks (CDNs) also reduce latency by caching content closer to users worldwide. New routing technologies like Cloudflare's Argo can improve performance by up to 59% by choosing network paths based on real-time conditions instead of following indirect routes. Overall, the document emphasizes that lower latency is key to optimizing the user experience on the web.
The document discusses the speed of the modern web. It summarizes key metrics around connection speeds, browser speeds, page weights, adoption of best practices, and page load times based on data from various sources. While some metrics like connection speeds and page load times are improving, pages overall are getting heavier and adoption of best practices is flat. The document advocates watching video growth, developing better performance metrics, promoting best practices more widely, utilizing multiple CPUs, and improving caching.
Extending the life of your device (firmware updates over LoRa) - LoRa AMMJan Jongboom
This document discusses extending the lifespan of IoT devices through firmware updates and outlines some challenges and solutions. It proposes a standardized approach using multicast transmissions, forward error correction, and an update server to efficiently deliver firmware over constrained low-power wide area networks. An open-source reference implementation is available to demonstrate feasibility on current hardware within radio regulations.
Practical Performance Tips and Tricks to Make Your HTML/JavaScript Apps FasterDoris Chen
How to tackle real-world web platform performance problems in modern websites and apps? This session starts with a basic understanding of the web platform and then explores to a set of problem/solution pairs built from industry-standard performance guidance. In the talk, we will demonstrate performance tips and tricks that will help you improve the performance of your apps and sites today. We will discuss the following respond to network requests, speed and responsiveness, optimizing media usage, and writing fast JavaScript. These performance tips and tricks apply equally to web sites that run on standards based web browsers, as well as to modern apps.
YOW2018 Cloud Performance Root Cause Analysis at NetflixBrendan Gregg
Keynote by Brendan Gregg for YOW! 2018. Video: https://www.youtube.com/watch?v=03EC8uA30Pw . Description: "At Netflix, improving the performance of our cloud means happier customers and lower costs, and involves root cause
analysis of applications, runtimes, operating systems, and hypervisors, in an environment of 150k cloud instances
that undergo numerous production changes each week. Apart from the developers who regularly optimize their own code
, we also have a dedicated performance team to help with any issue across the cloud, and to build tooling to aid in
this analysis. In this session we will summarize the Netflix environment, procedures, and tools we use and build t
o do root cause analysis on cloud performance issues. The analysis performed may be cloud-wide, using self-service
GUIs such as our open source Atlas tool, or focused on individual instances, and use our open source Vector tool, f
lame graphs, Java debuggers, and tooling that uses Linux perf, ftrace, and bcc/eBPF. You can use these open source
tools in the same way to find performance wins in your own environment."
This document discusses Apache Traffic Server, an open source HTTP proxy server. It provides an overview of Traffic Server's history and capabilities. Key points include:
- Traffic Server can handle a high volume of requests (350,000/sec) and throughput (30Gbps) for content delivery networks (CDNs).
- It uses an event-driven, multithreaded model to solve concurrency problems faced by other proxy servers.
- Traffic Server makes operations easy through automatic restart on crash, configuration reload without restart, and command line utilities for stats and configs.
- It can be used for forward and reverse proxying, load balancing, caching, and building CDNs through remapping of URLs to
Performance Tuning Oracle Weblogic Server 12cAjith Narayanan
The document summarizes techniques for monitoring and tuning Oracle WebLogic server performance. It discusses monitoring operating system metrics like CPU, memory, network and I/O usage. It also covers monitoring and tuning the Java Virtual Machine, including garbage collection. Specific tools are outlined for monitoring servers like the WebLogic admin console, and command line JVM tools. The document provides tips for configuring domain and server parameters to optimize performance, including enabling just-in-time starting of internal applications, configuring stuck thread handling, and setting connection backlog buffers.
The document outlines common problems and solutions for optimizing performance in Oracle Real Application Clusters (RAC). It discusses RAC fundamentals like architecture and cache fusion. Common problems discussed include lost blocks due to interconnect issues, disk I/O bottlenecks, and expensive queries. Diagnostics tools like AWR and ADDM can identify cluster-wide I/O and query plan issues impacting performance. Configuring the private interconnect, I/O, and addressing bad SQL can help resolve performance problems.
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.
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.
The document discusses strategies for improving front-end performance, especially for users on slow connections or mobile devices. It recommends dynamically adjusting content like images, scripts, and ads based on connection speed. Both client-side techniques using JavaScript and service workers as well as server-side methods like analyzing request headers and response times can help optimize the experience. Browsers are also intervening more aggressively to prioritize resources and content loading. The goal is to make websites faster and more usable for all users regardless of their network conditions.
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.
This document provides an overview of service workers and how they can be used. It begins with registering a service worker script and discussing the install and activate lifecycle events. It then covers using service workers to handle fetch events to provide offline functionality by precaching resources and serving cached responses when offline. Finally, it discusses several other potential uses of service workers like custom error pages, CDN failover, prefetching, and metrics collection.
Slides for my tutorial from Velocity 2014 on some of the more advanced features in WebPagetest.
Video is available on Youtube:
Part 1: http://youtu.be/6UeRMMI_IzI
Part 2: http://youtu.be/euVYHee1f1M
This document discusses techniques for optimizing image delivery on web pages. It recommends delay-loading hidden images, using lazy-loading attributes, delivering progressive JPEGs that display at lower quality first before higher quality, and using tools to convert images to progressive format to improve perceived page load speeds. Examples and links are provided to demonstrate how progressive JPEGs can display portions of images faster than regular JPEGs during loading.
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.
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.
Google I/O 2012 - Protecting your user experience while integrating 3rd party...Patrick Meenan
The amount of 3rd-party content included on websites is exploding (social sharing buttons, user tracking, advertising, code libraries, etc). Learn tips and techniques for how best to integrate them into your sites without risking a slower user experience or even your sites becoming unavailable.
Video is available here: http://www.youtube.com/watch?v=JB4ulhFFdH4&feature=plcp
The document discusses the frontend single point of failure (SPOF) problem caused by blocking JavaScript and CSS files. It provides examples of popular websites, code libraries, widgets, and content management systems that contribute to frontend SPOFs. The document recommends solutions for browsers, widget owners, CMS developers, and site owners to address this issue through asynchronous loading of resources and better monitoring of frontend performance.
Overview on why web performance matters, how to measure it and some discussion on 3rd-party content.
Presented t the DC area Web Manager's Roundtable group on 12/7/2011.
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.
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.
Coordinate Systems in FME 101 - Webinar SlidesSafe Software
If you’ve ever had to analyze a map or GPS data, chances are you’ve encountered and even worked with coordinate systems. As historical data continually updates through GPS, understanding coordinate systems is increasingly crucial. However, not everyone knows why they exist or how to effectively use them for data-driven insights.
During this webinar, you’ll learn exactly what coordinate systems are and how you can use FME to maintain and transform your data’s coordinate systems in an easy-to-digest way, accurately representing the geographical space that it exists within. During this webinar, you will have the chance to:
- Enhance Your Understanding: Gain a clear overview of what coordinate systems are and their value
- Learn Practical Applications: Why we need datams and projections, plus units between coordinate systems
- Maximize with FME: Understand how FME handles coordinate systems, including a brief summary of the 3 main reprojectors
- Custom Coordinate Systems: Learn how to work with FME and coordinate systems beyond what is natively supported
- Look Ahead: Gain insights into where FME is headed with coordinate systems in the future
Don’t miss the opportunity to improve the value you receive from your coordinate system data, ultimately allowing you to streamline your data analysis and maximize your time. See you there!
How RPA Help in the Transportation and Logistics Industry.pptxSynapseIndia
Revolutionize your transportation processes with our cutting-edge RPA software. Automate repetitive tasks, reduce costs, and enhance efficiency in the logistics sector with our advanced solutions.
論文紹介: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
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.
Best Programming Language for Civil EngineersAwais Yaseen
The integration of programming into civil engineering is transforming the industry. We can design complex infrastructure projects and analyse large datasets. Imagine revolutionizing the way we build our cities and infrastructure, all by the power of coding. Programming skills are no longer just a bonus—they’re a game changer in this era.
Technology is revolutionizing civil engineering by integrating advanced tools and techniques. Programming allows for the automation of repetitive tasks, enhancing the accuracy of designs, simulations, and analyses. With the advent of artificial intelligence and machine learning, engineers can now predict structural behaviors under various conditions, optimize material usage, and improve project planning.
Best Practices for Effectively Running dbt in Airflow.pdfTatiana Al-Chueyr
As a popular open-source library for analytics engineering, dbt is often used in combination with Airflow. Orchestrating and executing dbt models as DAGs ensures an additional layer of control over tasks, observability, and provides a reliable, scalable environment to run dbt models.
This webinar will cover a step-by-step guide to Cosmos, an open source package from Astronomer that helps you easily run your dbt Core projects as Airflow DAGs and Task Groups, all with just a few lines of code. We’ll walk through:
- Standard ways of running dbt (and when to utilize other methods)
- How Cosmos can be used to run and visualize your dbt projects in Airflow
- Common challenges and how to address them, including performance, dependency conflicts, and more
- How running dbt projects in Airflow helps with cost optimization
Webinar given on 9 July 2024
The DealBook is our annual overview of the Ukrainian tech investment industry. This edition comprehensively covers the full year 2023 and the first deals of 2024.
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.
Support en anglais diffusé lors de l'événement 100% IA organisé dans les locaux parisiens d'Iguane Solutions, le mardi 2 juillet 2024 :
- Présentation de notre plateforme IA plug and play : ses fonctionnalités avancées, telles que son interface utilisateur intuitive, son copilot puissant et des outils de monitoring performants.
- REX client : Cyril Janssens, CTO d’ easybourse, partage son expérience d’utilisation de notre plateforme IA plug & play.
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
How Social Media Hackers Help You to See Your Wife's Message.pdfHackersList
In the modern digital era, social media platforms have become integral to our daily lives. These platforms, including Facebook, Instagram, WhatsApp, and Snapchat, offer countless ways to connect, share, and communicate.
Understanding Insider Security Threats: Types, Examples, Effects, and Mitigat...Bert Blevins
Today’s digitally connected world presents a wide range of security challenges for enterprises. Insider security threats are particularly noteworthy because they have the potential to cause significant harm. Unlike external threats, insider risks originate from within the company, making them more subtle and challenging to identify. This blog aims to provide a comprehensive understanding of insider security threats, including their types, examples, effects, and mitigation techniques.
5. Fiber-to-the-home services provided 18 ms round-trip latency on average, while cable-based
services averaged 26 ms, and DSL-based services averaged 43 ms. This compares to 2011 figures of
17 ms for fiber, 28 ms for cable and 44 ms for DSL.
Measuring Broadband America - July 2012 - FCC
6. "Users of the Sprint 4G network can expect to experience average speeds of 3
Mbps to 6 Mbps download and up to 1.5 Mbps upload with an average latency of
150 ms. On the Sprint 3G network, users can expect to experience average speeds
of 600 Kbps - 1.4 Mbps download and 350 Kbps - 500 Kbps upload with an
average latency of 400 ms."
3G
4G
Sprint
400 ms
150 ms
AT&T
150 - 400 ms
100 - 200 ms
AT&T
7. ●
●
There is a one time cost for control-plane
negotiation
User-plane latency is the one-way latency between
packet availability in the device and packet at the
base station
LTE
Idle to connected latency
User-plane one-way latency
HSPA+
3G
< 100 ms
< 100 ms
< 2.5 s
< 5 ms
< 10 ms
< 50 ms
8. LTE power state transitions (AT&T)
●
●
●
●
Idle to Active: 260 ms control-plane latency
Dormant to Active: <50 ms control-plane latency (spec)
Timeout driven state transitions back to idle
○ 100 ms > Dormant
○ 10 s > Idle
Similar state machine for 3G devices
○ Except Control Plane latencies are much higher (1-2
seconds)
https://github.com/attdevsupport/ARO/blob/master/ARODataAnalyzer/src/lte.conf
11. 3G
(200 ms RTT)
4G
(80 ms RTT)
Control plane
(200-2500 ms)
(50-100 ms)
DNS lookup
200 ms
80 ms
TCP Connection
200 ms
80 ms
TLS handshake
(200-400 ms)
(80-160 ms)
HTTP request
200 ms
80 ms
600-3500 ms
240-500 ms
Total
Network overhead of
one HTTP request!
12. Typical Mobile Network Performance
Country
Average RTT
Average Downlink
Throughput
Average Uplink Throughput
South Korea
278 ms
1.8 Mbps
723 Kbps
Vietnam
305 ms
1.9 Mbps
543 Kbps
US
344 ms
1.6 Mbps
658 Kbps
UK
372 ms
1.4 Mbps
782 Kbps
Russia
518 ms
1.1 Mbps
439 Kbps
India
654 ms
1.2 Mbps
633 Kbps
Nigeria
892 ms
541 Kbps
298 Kbps
Compare to typical desktop and WiFi performance:
< 50 ms RTT, 5 Mbps throughput in the US
Source: Ookla/Speedtest.net
24. High Performance Websites
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
Make fewer HTTP requests
Use CDN
Add expires header
Gzip Components
Put stylesheets at the top
Put scripts at the bottom
Avoid CSS expressions
Make JS and CSS external
Reduce DNS lookups
Minify JS
Avoid redirects
Remove duplicate scripts
Configure Etags
Make Ajax cacheable
Sharding domains
27. TCP Initial Congestion Window
Upgraded from
Ubuntu 10.04 (2.6.32)
to 12.04 (3.2)
Base Page Download Time
28. WebP
●
●
●
●
40% smaller that jpeg for equivalent quality
Supports alpha + lossy
New losless support (26% smaller than PNG in testing)
Supported by Chrome and Opera
31. Watch out for Hidden Images (slideshows in particular)
Main gallery image competing with hidden images and background for bandwidth
32. 4 Shards
●
●
●
2 Shards
50-80ms faster page load times for image heavy pages (e.g. search)
○ 30-50ms faster overall.
Up to 500ms faster load times on mobile.
0.27% increase in pages per visit.
http://calendar.perfplanet.com/2013/reducing-domain-sharding/
33. Sync scripts block the parser...
Sync script will block the rendering of your page:
<script type="text/javascript"
src="https://apis.google.com/js/plusone.js"></script>
Async script will not block the rendering of your page:
<script type="text/javascript">
(function() {
var po = document.createElement('script'); po.type = 'text/javascript';
po.async = true; po.src = 'https://apis.google.com/js/plusone.js';
var s = document.getElementsByTagName('script')[0];
s.parentNode.insertBefore(po, s);
})();
</script>
34. Performance rules to keep in mind...
(1) JavaScript can block the DOM construction
(2) JavaScript can block on CSS
(3) Rendering is blocked on CSS...
Which means...
(1) Get CSS down to the client as fast as you can
○
Unblocks paints, removes potential JS waiting on CSS scenario
(2) If you can, use async scripts + avoid doc.write at all costs
○
○
Faster DOM construction, faster DCL and paint!
Do you need scripts in your critical rendering path?
36. Lazy Image Loaders
● Hide images from preloader (good)
● Reduce data use (good)
● Trigger resource loads at arbitrary times (bad)
○
May wake up radio and require 2-3s delay
● Balance bandwidth with experience and battery
○
Maybe load all delayed images after onload
47. Roll Your Own
● Send http beacon to beacon server
○ All timings as query params
○ 204 or transparent 1px gif
○ Log requests to access log
● IP, User Agent and Timings all in each
record
● access log -> logster -> statsd -> graphite
● Profit!
54. Experiment on webpagetest.org
●
Set session cookie to identify new/existing session
●
Set browser cookie and local cache value to track cache persistence
●
Track performance for sitewide js (site.js)
○
From Cache: responseStart == 0 || responseStart == requestStart