1. Meetup discussed optimizing the performance of their event details page by externalizing scripts, moving scripts to the bottom of the page, reducing requests, lazy loading scripts, and using event delegation.
2. These changes reduced the page load time by 27% from 6.321 seconds to 4.643 seconds and reduced javascript requests by 50%.
3. Meetup also optimized static content serving by versioning, compressing, caching resources and using a CDN to improve performance further.
This document discusses optimizing Meetup's performance by reducing page load times. It recommends reducing JavaScript, image, DOM, and CSS files. Specific techniques include externalizing and concatenating JavaScript, lazy loading images and scripts, minimizing DOM elements, writing efficient CSS selectors, and profiling code to optimize loops and DOM manipulation. Reducing page weight through these techniques can improve the user experience by speeding up load times and drop in member activity.
Cool like a Frontend Developer: Grunt, RequireJS, Bower and other ToolsRyan Weaver
Bower, Grunt, and RequireJS are just a few tools that have been re-shaping the frontend development world, replacing cluttered script tags and server-side build solutions with a sophisticated, but sometimes complex approach to dependency management and module loading. In this talk, we'll put on our trendy frontend developer hat and find out how these tools work and how they differ from what we might be used to. Most important, we'll see how using tools like this might look in Symfony2 and how our application can be a friendly place for a frontend guy/gal.
This document provides an overview of the Grunt task runner. It discusses Grunt basics like minifying, concatenating, and linting files. It also covers Grunt configuration including initConfig, tasks, files, and templates. Custom tasks, asynchronous tasks, and importing external data are described. The document recommends Grunt for its large community, strong adoption, valuable skills, and ability to easily automate common development tasks.
Flash over the years, has been used to prop up the regular browser like a sad old man drinking alone in a pub.
Today browsers come shipped with technology designed to rival flash and aim to shut it squarely out of the game.
Are browser ready to rock without Flash?
RSVP Node.js class at www.nycdatascience.com
NYC data science academy's free workshop, given at NYC Open Data Meetup, http://www.meetup.com/NYC-Open-Data/events/163300552/
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?
Slides from Node.js and Twitter Bootstrap crash course given to Penn Graduate Computing Club. Covers creating basic node app, using the bootstrap grid, and deploying to an EC2 machine.
This document discusses optimizing Meetup's performance by reducing page load times. It recommends reducing JavaScript, image, DOM, and CSS files. Specific techniques include externalizing and concatenating JavaScript, lazy loading images and scripts, minimizing DOM elements, writing efficient CSS selectors, and profiling code to optimize loops and DOM manipulation. Reducing page weight through these techniques can improve the user experience by speeding up load times and drop in member activity.
Cool like a Frontend Developer: Grunt, RequireJS, Bower and other ToolsRyan Weaver
Bower, Grunt, and RequireJS are just a few tools that have been re-shaping the frontend development world, replacing cluttered script tags and server-side build solutions with a sophisticated, but sometimes complex approach to dependency management and module loading. In this talk, we'll put on our trendy frontend developer hat and find out how these tools work and how they differ from what we might be used to. Most important, we'll see how using tools like this might look in Symfony2 and how our application can be a friendly place for a frontend guy/gal.
This document provides an overview of the Grunt task runner. It discusses Grunt basics like minifying, concatenating, and linting files. It also covers Grunt configuration including initConfig, tasks, files, and templates. Custom tasks, asynchronous tasks, and importing external data are described. The document recommends Grunt for its large community, strong adoption, valuable skills, and ability to easily automate common development tasks.
Flash over the years, has been used to prop up the regular browser like a sad old man drinking alone in a pub.
Today browsers come shipped with technology designed to rival flash and aim to shut it squarely out of the game.
Are browser ready to rock without Flash?
RSVP Node.js class at www.nycdatascience.com
NYC data science academy's free workshop, given at NYC Open Data Meetup, http://www.meetup.com/NYC-Open-Data/events/163300552/
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?
Slides from Node.js and Twitter Bootstrap crash course given to Penn Graduate Computing Club. Covers creating basic node app, using the bootstrap grid, and deploying to an EC2 machine.
modern module development - Ken Barber 2012 Edinburgh Puppet CampPuppet
The document provides information on modern Puppet module development best practices. It discusses what modules are and common patterns like package, config, service that address 80% of module needs. It also covers validation of module parameters using Kwalify schemas, testing modules with rspec-puppet, and packaging modules for release on the Puppet Forge using the puppet-module tool. The document emphasizes the importance of coding style, linting with puppet-lint, and following patterns and best practices to create high quality, reusable modules.
Finally, Professional Frontend Dev with ReactJS, WebPack & Symfony (Symfony C...Ryan Weaver
If you're like me, you know that being a great backend developer isn't enough. To make *truly* great applications, we need to spend significant time in an area that's moving at a lightning pace: frontend development.
This talk is for you: the backend developer that wants to hook their API's up to rich, interactive JavaScript frontends. To do that, first, we need to demystify a lot of new terms, like ES6/ES2015, ECMAScript, JSX, Babel and the idea that modern JavaScript (surprise) *requires* a build step.
With this in mind, I'll give you a brief introduction into Webpack & the modular development it finally allows.
But the real star is ReactJS. In the frontend world, you never know what new tech will *win*, but React is a star. I'll give you enough of an intro to get you rolling on your project.
The new frontend dev world is huge! Consider the starting line down an exciting new journey.
#NoXML: Eliminating XML in Spring Projects - SpringOne 2GX 2015Matt Raible
Many Spring projects exist that leverage XML for their configuration and bean definitions. Most Java web applications use a web.xml to configure their servlets, filters and listeners. This session shows you how you can eliminate XML by configuring your Spring beans with JavaConfig and annotations. It also shows how you can remove your web.xml and configure your web components with Java.
The document discusses the messy and buggy state of the DOM across browsers and strategies for writing cross-browser JavaScript code. It notes that nearly every DOM method has bugs or inconsistencies in some browsers. It then covers strategies like feature detection, graceful fallback for missing features, simulating features via workarounds, monitoring for regressions, and having a robust test suite to prevent regressions in one's own code. The overall message is that the DOM is messy and one needs to "know your enemies" by thoroughly testing code in all target browsers.
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
The document discusses various security vulnerabilities in Ajax applications including CSRF, login CSRF, JavaScript hijacking, XSS, and history stealing. It provides examples of how these attacks can be carried out and emphasizes the importance of validating and sanitizing user input to prevent scripts from being executed maliciously on a site. The document also recommends techniques for protecting against these attacks, such as using authentication tokens and disabling client-side script evaluation for untrusted sources.
Keeping the frontend under control with Symfony and WebpackIgnacio Martín
Webpack tutorial with tips for Symfony users. Topics covered include: current frontend trends, setup, loaders, dev tools, optimization in production, bundle splitting and tips and tricks for using webpack with existing projects.
Symfony Munich Meetup 2016.
Eddystone Beacons - Physical Web - Giving a URL to All ObjectsJeff Prestes
More mobile technologies are empowering people and machines to become more autonomous. In the same way as people, machines need ways to be identified to other sources in a connected environment. This begs the question, why not give a URL to objects? With Eddystone, a new Google specification for Beacon data, this is possible, and it works with both Android and iOS based devices.
With it you can implement what physical-web.org stands
The average website loads over 1.5MBs of content per page, making over 75 requests. Many popular websites are serving over 5MBs just to load their homepages. And these numbers represent measurements taken AFTER compression is applied. The full weight of many popular websites is pushing 20+ MBs these days. In an era where performance truly matters to the end user experience, web developers need techniques to help curtail this bloat in data down the wire.
No matter how well you optimize, there is no better way than to delete things you do not need. How does one determine what is essential to the user experience and what is not? One answer Chris posits is to develop a hyper-lightweight version of your website which will provide critical insights into your specific performance priorities. This is a process that he has leveraged on many projects, in particular at YouTube to reduce the size of the video watch page from 1.5MBs to 100KBs. In this talk, Chris will take real-world web pages and show techniques for dramatically reducing their page weight and for identifying areas to optimize, while outlining the key steps to doing this well.
This document provides an overview of building a content management system (CMS) using Apache Sling. It discusses how Sling uses OSGi and the Java Content Repository to provide a RESTful framework. Example uses of Sling include content CRUD operations via the Sling Post Servlet and resource resolution. The document then demonstrates how to set up a Sling development environment and build sample pages that include a WYSIWYG editor and image uploads using Sling and technologies like JavaScript, jQuery, Bootstrap and Groovy.
The Art of AngularJS in 2015 - Angular Summit 2015Matt Raible
Presentation from Angular Summit Keynote in September 2015. http://angularsummit.com/conference/boston/2015/09/session?id=34212
AngularJS is one of today's hottest JavaScript MVC Frameworks. In this session, we'll explore many concepts it brings to the world of client-side development: dependency injection, directives, filters, routing and two-way data binding. We'll also look at its recommended testing tools and build systems.
Performance optimization is a crucial aspect of building ‘snappy’ client-side applications and something which all developers using jQuery should bear in mind. In this talk, we're going to take a look at some of the best practices, tips and tricks for improving the performance of your jQuery code in 2011 with some quick wins and a few new surprises along the way.
Browser Wars Episode 1: The Phantom MenaceNicholas Zakas
This document summarizes the history and evolution of web browsers and internet technologies from the early 1990s to the late 1990s. It traces the development of key browsers like Netscape Navigator and Internet Explorer. It also outlines the introduction of important web standards like HTML, CSS, JavaScript and XML. Major events included the commercialization of the web in the mid-1990s, the browser wars between Netscape and Microsoft in the late 90s, and the consolidation of online services providers toward the end of the decade.
Angular를 활용한 웹 프론트단 개발과 2.0에서 달라진점Jeado Ko
Angular를 활용한 웹 프론트단 개발과 2.0에서 달라진점은 Angular 2.0에서 컴포넌트 기반 아키텍처로 변경되었다고 설명했습니다. Angular 2.0에서는 타입스크립트를 사용하며 컴포넌트, 디렉티브, 템플릿 등의 개념이 도입되었습니다. 또한 Angular 2.0
High Performance JavaScript - WebDirections USA 2010Nicholas Zakas
This document summarizes Nicholas C. Zakas' presentation on high performance JavaScript. It discusses how the browser UI thread handles both UI updates and JavaScript execution sequentially. Long running JavaScript can cause unresponsive UIs. Techniques to ensure responsive UIs include limiting JavaScript execution time, using timers or web workers to break up processing, reducing repaints and reflows, and grouping style changes. Hardware acceleration and optimizing JavaScript engines have improved performance but responsive UIs still require discipline.
Bootstrap is a popular HTML, CSS, and JS framework for building responsive mobile-first projects. It provides predefined grid and layout components, forms, buttons, navigation menus and other interface elements for a consistent user experience across devices. The framework is open source, supports all major browsers, and can be easily customized.
In the beginning, progressive enhancement was simple: HTML layered with CSS layered with JavaScript. That worked fine when there were two browsers, but in today's world of multiple devices and multiple browsers, it's time for a progressive enhancement reboot. At the core is the understanding that the web is not print - the same rules don't apply. As developers and consumers we've been fooled into thinking about print paradigms for too long. In this talk, you'll learn just how different the web is and how the evolution of progressive enhancement can lead to better user experiences as well as happier developers and users.
This deck is a conference-agnostic one, suitable to be shown anywhere without site-specific jokes!
jQuery 1.9 and 2.0 - Present and FutureRichard Worth
The document discusses jQuery 1.9, 2.0, and the future of jQuery, noting that jQuery 2.0 drops support for older browsers like IE6-8 but is 12% smaller, and introduces 12 optionally excludable modules; it promises that jQuery 1.X will be supported as long as older IE browsers are relevant and that API equivalence will be maintained between 1.X and 2.X versions; and it invites attendees to join and contribute to the jQuery community.
Presented at Bucharest Java User Group, http://www.bjug.ro/editii/5.html . Project source code available at: https://github.com/bucharest-jug/dropwizard-todo
Introduction to Client Side Dev in SharePoint WorkshopMark Rackley
The document is a presentation on client side development in SharePoint using jQuery. It begins with introductions and an agenda. The agenda covers deploying and referencing scripts, a jQuery primer, debugging techniques, modifying default SharePoint forms, REST/CSOM/SPServices, third party libraries, and SharePoint hosted apps. It then discusses why client side development is useful and challenges like browser inconsistencies. Best practices covered include avoiding global variables and writing performant code. Various development tools are presented. Finally, a demo is shown of building a simple contract management solution using the techniques discussed.
modern module development - Ken Barber 2012 Edinburgh Puppet CampPuppet
The document provides information on modern Puppet module development best practices. It discusses what modules are and common patterns like package, config, service that address 80% of module needs. It also covers validation of module parameters using Kwalify schemas, testing modules with rspec-puppet, and packaging modules for release on the Puppet Forge using the puppet-module tool. The document emphasizes the importance of coding style, linting with puppet-lint, and following patterns and best practices to create high quality, reusable modules.
Finally, Professional Frontend Dev with ReactJS, WebPack & Symfony (Symfony C...Ryan Weaver
If you're like me, you know that being a great backend developer isn't enough. To make *truly* great applications, we need to spend significant time in an area that's moving at a lightning pace: frontend development.
This talk is for you: the backend developer that wants to hook their API's up to rich, interactive JavaScript frontends. To do that, first, we need to demystify a lot of new terms, like ES6/ES2015, ECMAScript, JSX, Babel and the idea that modern JavaScript (surprise) *requires* a build step.
With this in mind, I'll give you a brief introduction into Webpack & the modular development it finally allows.
But the real star is ReactJS. In the frontend world, you never know what new tech will *win*, but React is a star. I'll give you enough of an intro to get you rolling on your project.
The new frontend dev world is huge! Consider the starting line down an exciting new journey.
#NoXML: Eliminating XML in Spring Projects - SpringOne 2GX 2015Matt Raible
Many Spring projects exist that leverage XML for their configuration and bean definitions. Most Java web applications use a web.xml to configure their servlets, filters and listeners. This session shows you how you can eliminate XML by configuring your Spring beans with JavaConfig and annotations. It also shows how you can remove your web.xml and configure your web components with Java.
The document discusses the messy and buggy state of the DOM across browsers and strategies for writing cross-browser JavaScript code. It notes that nearly every DOM method has bugs or inconsistencies in some browsers. It then covers strategies like feature detection, graceful fallback for missing features, simulating features via workarounds, monitoring for regressions, and having a robust test suite to prevent regressions in one's own code. The overall message is that the DOM is messy and one needs to "know your enemies" by thoroughly testing code in all target browsers.
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
The document discusses various security vulnerabilities in Ajax applications including CSRF, login CSRF, JavaScript hijacking, XSS, and history stealing. It provides examples of how these attacks can be carried out and emphasizes the importance of validating and sanitizing user input to prevent scripts from being executed maliciously on a site. The document also recommends techniques for protecting against these attacks, such as using authentication tokens and disabling client-side script evaluation for untrusted sources.
Keeping the frontend under control with Symfony and WebpackIgnacio Martín
Webpack tutorial with tips for Symfony users. Topics covered include: current frontend trends, setup, loaders, dev tools, optimization in production, bundle splitting and tips and tricks for using webpack with existing projects.
Symfony Munich Meetup 2016.
Eddystone Beacons - Physical Web - Giving a URL to All ObjectsJeff Prestes
More mobile technologies are empowering people and machines to become more autonomous. In the same way as people, machines need ways to be identified to other sources in a connected environment. This begs the question, why not give a URL to objects? With Eddystone, a new Google specification for Beacon data, this is possible, and it works with both Android and iOS based devices.
With it you can implement what physical-web.org stands
The average website loads over 1.5MBs of content per page, making over 75 requests. Many popular websites are serving over 5MBs just to load their homepages. And these numbers represent measurements taken AFTER compression is applied. The full weight of many popular websites is pushing 20+ MBs these days. In an era where performance truly matters to the end user experience, web developers need techniques to help curtail this bloat in data down the wire.
No matter how well you optimize, there is no better way than to delete things you do not need. How does one determine what is essential to the user experience and what is not? One answer Chris posits is to develop a hyper-lightweight version of your website which will provide critical insights into your specific performance priorities. This is a process that he has leveraged on many projects, in particular at YouTube to reduce the size of the video watch page from 1.5MBs to 100KBs. In this talk, Chris will take real-world web pages and show techniques for dramatically reducing their page weight and for identifying areas to optimize, while outlining the key steps to doing this well.
This document provides an overview of building a content management system (CMS) using Apache Sling. It discusses how Sling uses OSGi and the Java Content Repository to provide a RESTful framework. Example uses of Sling include content CRUD operations via the Sling Post Servlet and resource resolution. The document then demonstrates how to set up a Sling development environment and build sample pages that include a WYSIWYG editor and image uploads using Sling and technologies like JavaScript, jQuery, Bootstrap and Groovy.
The Art of AngularJS in 2015 - Angular Summit 2015Matt Raible
Presentation from Angular Summit Keynote in September 2015. http://angularsummit.com/conference/boston/2015/09/session?id=34212
AngularJS is one of today's hottest JavaScript MVC Frameworks. In this session, we'll explore many concepts it brings to the world of client-side development: dependency injection, directives, filters, routing and two-way data binding. We'll also look at its recommended testing tools and build systems.
Performance optimization is a crucial aspect of building ‘snappy’ client-side applications and something which all developers using jQuery should bear in mind. In this talk, we're going to take a look at some of the best practices, tips and tricks for improving the performance of your jQuery code in 2011 with some quick wins and a few new surprises along the way.
Browser Wars Episode 1: The Phantom MenaceNicholas Zakas
This document summarizes the history and evolution of web browsers and internet technologies from the early 1990s to the late 1990s. It traces the development of key browsers like Netscape Navigator and Internet Explorer. It also outlines the introduction of important web standards like HTML, CSS, JavaScript and XML. Major events included the commercialization of the web in the mid-1990s, the browser wars between Netscape and Microsoft in the late 90s, and the consolidation of online services providers toward the end of the decade.
Angular를 활용한 웹 프론트단 개발과 2.0에서 달라진점Jeado Ko
Angular를 활용한 웹 프론트단 개발과 2.0에서 달라진점은 Angular 2.0에서 컴포넌트 기반 아키텍처로 변경되었다고 설명했습니다. Angular 2.0에서는 타입스크립트를 사용하며 컴포넌트, 디렉티브, 템플릿 등의 개념이 도입되었습니다. 또한 Angular 2.0
High Performance JavaScript - WebDirections USA 2010Nicholas Zakas
This document summarizes Nicholas C. Zakas' presentation on high performance JavaScript. It discusses how the browser UI thread handles both UI updates and JavaScript execution sequentially. Long running JavaScript can cause unresponsive UIs. Techniques to ensure responsive UIs include limiting JavaScript execution time, using timers or web workers to break up processing, reducing repaints and reflows, and grouping style changes. Hardware acceleration and optimizing JavaScript engines have improved performance but responsive UIs still require discipline.
Bootstrap is a popular HTML, CSS, and JS framework for building responsive mobile-first projects. It provides predefined grid and layout components, forms, buttons, navigation menus and other interface elements for a consistent user experience across devices. The framework is open source, supports all major browsers, and can be easily customized.
In the beginning, progressive enhancement was simple: HTML layered with CSS layered with JavaScript. That worked fine when there were two browsers, but in today's world of multiple devices and multiple browsers, it's time for a progressive enhancement reboot. At the core is the understanding that the web is not print - the same rules don't apply. As developers and consumers we've been fooled into thinking about print paradigms for too long. In this talk, you'll learn just how different the web is and how the evolution of progressive enhancement can lead to better user experiences as well as happier developers and users.
This deck is a conference-agnostic one, suitable to be shown anywhere without site-specific jokes!
jQuery 1.9 and 2.0 - Present and FutureRichard Worth
The document discusses jQuery 1.9, 2.0, and the future of jQuery, noting that jQuery 2.0 drops support for older browsers like IE6-8 but is 12% smaller, and introduces 12 optionally excludable modules; it promises that jQuery 1.X will be supported as long as older IE browsers are relevant and that API equivalence will be maintained between 1.X and 2.X versions; and it invites attendees to join and contribute to the jQuery community.
Presented at Bucharest Java User Group, http://www.bjug.ro/editii/5.html . Project source code available at: https://github.com/bucharest-jug/dropwizard-todo
Introduction to Client Side Dev in SharePoint WorkshopMark Rackley
The document is a presentation on client side development in SharePoint using jQuery. It begins with introductions and an agenda. The agenda covers deploying and referencing scripts, a jQuery primer, debugging techniques, modifying default SharePoint forms, REST/CSOM/SPServices, third party libraries, and SharePoint hosted apps. It then discusses why client side development is useful and challenges like browser inconsistencies. Best practices covered include avoiding global variables and writing performant code. Various development tools are presented. Finally, a demo is shown of building a simple contract management solution using the techniques discussed.
Grâce aux tags Varnish, j'ai switché ma prod sur Raspberry PiJérémy Derussé
Le moyen le plus rapide d'obtenir une réponse d'un Backend est de ne pas l'appeler ;-) Une solution fournie par les "reverse-proxy" me direz-vous, mais pas si simple d'invalider le cache...
Ce talk aborde une fonctionnalité méconnue de Varnish: les tags. Nous verrons comment en tirer partie via les "event listeners" d'une application Symfony standard. Au menu, un cluster de Rasberry Pi, une API, et des données toujours fraîches sous la milliseconde.
CollabSphere 2021 - DEV114 - The Nuts and Bolts of CI/CD With a Large XPages ...Jesse Gallagher
Though Domino makes working with build servers and CI/CD pipelines difficult, it is possible to do so even with complex applications. This session will discuss the specifics of using several OpenNTF projects - NSF ODP Tooling, the Jakarta XPages Runtime, and XPages Jakarta EE Support - as well as open-source technologies such as Docker to build, test, and deploy Java-based Domino applications for testing and staging. This builds on previous sessions about the NSF ODP Tooling and Maven generally.
The document discusses optimization of the presentation tier of web applications. It notes that the presentation tier is often overlooked despite being responsible for over 30% of client/server performance. Some key optimizations discussed include reducing HTTP requests, optimizing response objects by reducing size and load pattern, JavaScript minification and placement, image sprites, caching, and ensuring valid HTML markup.
A complete guide of optimizing Magento performance systematically, including LAMP(Linux, Apache, MySQL, PHP) optimization, tuning inside Magento and useful tools.
This document discusses strategies for making Ruby on Rails applications highly available. It covers common architectures using a single server, and moving to distributed systems. Key topics include application modularity, useful gems for asynchronous processing, database replication, session management, application deployment, configuration management, and load balancing. The conclusion emphasizes that porting Rails apps to a highly available environment requires thinking about architecture and distribution early, but is not prohibitively difficult if approached methodically.
Deploying configurable frontend web application containersJosé Moreira
Deploying containerized client-side web applications requires a different configuration strategy compared to system applications. The runtime of client-side web applications is the client-side web browser and, unlike other applications which can utilize environment values, configuration has to be hard-coded in the Javascript source code.
This document discusses profiling PHP applications to improve performance. It recommends profiling during development to identify inefficiencies. The document introduces Xdebug for profiling PHP code and Webgrind, a PHP frontend for visualizing Xdebug profiles. It provides an example of profiling a sample PHP application, identifying issues, making code changes, and verifying performance improvements through re-profiling.
Web Performance Part 4 "Client-side performance"Binary Studio
The presentation is devoted to client side performance of a web app. All 4 presentations will help you reduce latency, enrich optimization of javascript code, discover tricky parts when working with API browser, see best practices of networking and learn lots of other important and interesting things. Enjoy! =)
This document discusses several techniques for improving website performance by optimizing JavaScript loading and execution. It recommends splitting large JavaScript files into smaller grouped files, stubbing functions that are not called initially, embedding JSON data to avoid additional AJAX calls, rendering initial HTML server-side, and using placeholders to indicate progressive loading. The document emphasizes that homepage load speed is critical and cautions against overloading users by caching unnecessary scripts.
The document discusses the Dojo build system which optimizes JavaScript applications by compressing files, combining files into one, resolving CSS imports, and removing unnecessary code and whitespace. It describes build profiles that specify layers and modules, and options for the build script like optimization settings. Running the build script cleans and releases an optimized version of the application to improve loading performance.
TDC2017 | Florianopolis - Trilha DevOps How we figured out we had a SRE team ...tdc-globalcode
The document discusses the history and evolution of JavaScript packaging and module bundling from 2000 to the present. It covers early approaches using individual script tags to load JS files, the introduction of minification tools like JSMin in 2003, concatenating files together in the late 2000s, module loaders like RequireJS in 2009, the rise of Node.js and package managers in 2010, and the modern dominance of bundlers like Webpack since 2014 which use loaders to bundle dependencies and assets into single files or chunks.
Webpack is a module bundler that packs JavaScript files and their dependencies into small bundles for efficient loading on the browser. It builds a dependency graph by walking through imports and outputs bundles or individual files. Loaders allow transforming assets and piping them together, like using babel-loader to transpile JSX to ES5 and css-loader to bundle CSS. This summarizes the key points about Webpack's purpose, how it builds dependencies, and the role of loaders.
In this session we will present an overview from the point of view 'system that implementative on how to get the best performance from your drupal application.
We will also show examples of use cases for drupal scalable infrastructure.
The document discusses various technologies and concepts related to modern software development, including PHP and frameworks like Laravel for web development, databases like MySQL and NoSQL options, version control with Git, software development methodologies like waterfall and agile approaches, testing and continuous integration. Key points covered include using PHP with MySQL, NoSQL databases like MongoDB and their data structures, Git for version control, testing tools, and best practices for continuous integration.
This document discusses various topics related to developing web apps, including HTML5, responsive design, touch events, offline capabilities, and debugging tools. It provides links to resources on HTML5 features like media queries, SVG, web workers, and the page visibility API. It also covers techniques for adapting content like responsive web design, progressive enhancement, and server-side adaptation. Mobile browser stats and popular devices on Douban are mentioned. Frameworks like Bootstrap and tools like Weinre for debugging mobile apps are referenced.
This document discusses various techniques for making web applications work offline and with unreliable network connections, including:
- The application cache manifest which allows specifying cached resources to work offline
- Issues with the current manifest specification and potential enhancements
- The window.applicationCache API for caching resources and monitoring cache status
- Detecting online/offline status using the navigator.onLine property
In 3 sentences or less, it summarizes approaches for offline web applications using the application cache manifest, applicationCache API, and navigator.onLine property.
Derek Willian Stavis (Pagar.me)
Todo mundo diz que Webpack é só um module bundler. Mas o que é um módulo? O que é um bundler? Porque precisamos disso? Vamos caminhar pela história do desenvolvimento web para entender estes conceitos, e no final vamos dissecar a configuração e o output do Webpack para entendermos como ele funciona e como ele pode facilitar o seu processo de desenvolvimento.
Vale do Carbono Conference
1. Meetup Performance
Greg Whalin, CTO Meetup (@gwhalin), Justin Cataldo, Lead UI Engineer (@jcataldo), Will Howard, Lead UI Engineer
2. Meetup
Platform for local groups
Mission is MEME (Meetup Everywhere About Most Everything)
~6.2m members
~70k Groups
~500k group joins every month
~5 million Meetups have happened
~53 million RSVPs
3. General Architecture and Back-
end Performance
(just a tiny bit - this could and
should be another presentation)
4. Data
MySQL (any RDBMs store) biggest pain
replication
use InnoDB!
smart indexing (take advantage of clustered indexes)
server side conn pools and short timeouts on connections
smart about fs choice on Linux (we use XFS after benchmarking)
Hardware - relatively expensive boxes
multi-core (8 or 16) Opteron
lots of ram (32/64GB)
fast drives (lots of spindles, RAID10)
Cache, cache, cache!
innodb buffer cache
memcache
local app server memory
Shrink data when possible
archive unused data
custom serialization when serializing
data partitioning/sharding
5. Storage
Over half a million photos uploaded to Meetup every month
Scaled and processed into 4 different sizes (plus original)
6. Storage solutions
Options for growth include NAS, SAN, or something else
NAS and SAN are single point of failure and possibly $$$
Only postpones problem
7. MogileFS
developed by Brand Fitzpatrick (i.e. Memcached)
OSS distributed filesystem (built in Perl)
any hard drive on network can easily be added to cluster
scales easily and cheaply
13. Why does performance matter?
Slow site
Bad User Experience
Drop in Member
Activity
14. Why focus on front end performance?
Back end only accounts for 10-15% of the response time
Less time and resources
Costs less
http://developer.yahoo.net/blog/archives/2007/03/high_performanc.html
19. 3 Steps to improving performance
1. Externalize script
2. Move scripts to the bottom of the page
3. Reduce requests
20. 3 Steps to improving performance
1. Externalize script
2. Move scripts to the bottom of the page
3. Reduce requests
21. Why externalize scripts
Prevents blocking
Inline scripts prevent asynchronous downloads
Downloads must wait for the script to be executed
Caching
Inline JavaScript is downloaded every time
External scripts are cached by the browser
Reduced overall page size
Reusable
Can use the same code somewhere else on the site
easily
23. 3 Steps to improving performance
1. Externalize script
2. Move scripts to the bottom of the page
3. Reduce requests
24. Web:script
Custom tag built in house
Moves inline and external script to the bottom of the page
Allows UI engineers to not have to worry about where they
place scripts
Compresses inline script using YUICompressor
/***** Load External Script *****/
<web:script src="/script/Meetup/packed/EventDetails.js" />
/***** Load Inline Script *****/
<web:script>
Meetup.Copy.noMembersMarkedAttended = "<trn:message key="event.attendance.noMembersMarkedAttended">No
members have been marked attended</trn:message>";
Meetup.Copy.noMembersMarkedAttendedDynam = '<trn:message key="event.attendance.
noMembersMarkedAttendedDynam"><trn:param name="GROUPING">__GROUPING__</trn:param>No members in
"{GROUPING}" have been marked attended</trn:message>';
Meetup.Copy.noMembersMarkedAbsent = "<trn:message key="event.attendance.noMembersMarkedAbsent">No
members have been marked absent</trn:message>";
</web:script>
25. 3 Steps to improving performance
1. Externalize script
2. Move scripts to the bottom of the page
3. Reduce requests
27. Concatenation using Sprockets
Sprockets (www.getsprockets.com)
Created by 37Signals
Ruby library that preprocesses and concatenates JavaScript
files
Baked into our build process
30. Lazy Loading
Defer loading of javascript files until they are needed
Reduces the initial upfront requests
Helps reduce blocking by downloading files asynchronously
Precaching
31. Lazy Loading: How it works
Inserts scripts into the head dynamically
var scriptNode = function(src) {
return createDOM("script", {
"type": "text/javascript",
"src": src
});
}
var load = function(id, src, n) {
var script = scriptNode(url);
head.appendChild(script);
script.onload = script.onreadystatechange = function() {
if (!this.readyState || this.readyState == "loaded" || this.readyState == "complete") {
script.onload = script.onreadystatechange = null;
}
}
}
Meetup.Script.include("http://static2.meetupstatic.com/script/Meetup/DomDeco/LinkDecorator.js",callback);
38. Execute early: DOMReady
Libraries that have a DOM ready solution:
jQuery
YUI
Prototype
Pretty much every modern JS library (not MochiKit)
Meetup uses MochiKit, so we rolled our own.
39. Execute early: DOMReady
And by rolled our own, I mean we're using the Dean
Edwards/Matthias Miller/John Resig implementation.
http://dean.edwards.name/weblog/2006/06/again/#comment5338
With a few changes.
Meetup.DOMReady.ready(function(){
Meetup.EventDetails.init();
if(Meetup.EventDetails.isCanceled != 4 && Meetup.EventDetails.rsvp != 0){
deletePopup = new Meetup.CommentDeleteConfirm();
deletePopup.pagerOffsetFieldName = "p_commentsList";
deletePopup._decorate();
}
});
40. Execute early: Even earlier
Do you need to wait for the DOM to be ready?
If you aren't manipulating the DOM, there's no reason to
wait until it's ready.
41. Automated Image Optimization
Using smush.it
http://developer.yahoo.com/yslow/smushit/
Smusher Ruby gem
http://github.com/grosser/smusher (gem install smusher)
BASH script that watches our image directories for
changes and executes smusher.
./filescan.sh /usr/local/meetup/static/img/ 'smusher -q @' 'jpg,png'&
43. Event Delegation
But first, a little bit about event bubbling...
From: http://www.quirksmode.org/js/events_order.html
44. Event Delegation
Pros Cons
Does not work well with nested elements
Much faster on load (not
Doesn't work with all events
connecting DOM elements)
Slight performance hit with execution
No need to disconnect /
reconnect with AJAX calls
Fewer memory leaks
A lot of JS libraries already have plug-ins for event
delegation (jQuery, YUI, prototype).
But, it's pretty easy to write your own (we did).
47. Event Delegation: Meetup.Dispatcher
<div id="C_page">
...
<span class="meetup-topic"><a class="topic-id-7029 topic-link J_onClick topic-info-hover" href="
http://javascript.meetup.com/cities/us/ny/brooklyn/">JavaScript</a></span>
...
</div>
// Inits a new instance of dispatcher
// Connects a mouseover event to the parent container "C_page"
var mdp = Meetup.Dispatcher.init("C_page", "onmouseover");
// Calls Meetup.UI.infoHover.mouseOver() when target element has "topic-info-hover" class.
mdp.registerFunc("topic-info-hover", Meetup.UI.InfoHover.mouseOver);
Meetup.UI.infoHover.mouseOver = function(e) {
topicId = _getTopicId(e.target());
if (!topicId || topicId == "") return;
_primeCache(topicId);
var activeEl = _getActiveEl(e.target());
var pos = getElementPosition(activeEl);
...
}
48. Speeding up DOM crawling with Sizzle
sizzlejs.com
Internet Explorer 7
MochiKit: 6623.94ms
Sizzle: 306.03ms
Firefox 3.5
MochiKit: 210.524ms
Sizzle: 111.553ms
49. Where do we go from here?
More concatenation and lazy loading where it makes sense
Defer image loading where it makes sense
Reduce DOM elements
Reduce CSS and improved selector efficiency
and more
51. Launches
Launch multiple times a day (sometimes)
Need launches to be quick / no downtime
Optimize static resources only at deploy time and only if
modified
52. Deployment of static content
Sprockets (reduce requests)
YUICompressor for js (local mod to speed up optimizing
multiple files)
Pre-compress css and jsp
Set cache-control to be fresh for over a year (indefinite)
All links on site generate programatically and versioned