Angular Performance: Then, Now and the Future. Todd MottoFuture Insights
This document summarizes AngularJS performance features discussed by Todd Motto, a Google Developer Expert and lead engineer at Mozio. The summary includes:
1. Angular 1.2 to 1.3 brought major performance improvements like IE8 support being dropped, DOM manipulation being 4.3 times faster, and the $digest loop being 3.5 times faster.
2. New features in 1.3 like one-time bindings, ngModelOptions, and bindToController help optimize performance.
3. Todd Motto discusses techniques for improving Angular performance like minimizing $watches, using $applyAsync with $http, disabling debug info, and avoiding expensive DOM filters.
4. The
The document discusses RSpec, a behavior-driven development (BDD) framework for testing Ruby code. It describes how RSpec allows writing tests in a natural language style using "should" statements. Examples are provided for different types of RSpec tests, including model, controller, and view tests. Shared examples, custom matchers, and integration with Cucumber for writing tests in a storytelling format are also covered. The document concludes with information on installing and running RSpec and generating reports from test results.
Excellent is a static analysis gem that finds the nasty lines in your code. It implements a comprehensive set of checks for possibly buggy parts of your app that would otherwise make it into your repo and eventually to the production server.
Slides from my Lonestar Ruby Conf 2011 presentation.
*** Video of presentation: http://confreaks.com/videos/2531-lsrc2011-testing-javascript-with-jasmine ***
Agenda:
- Briefly cover why you should unit test
- Discuss what Jasmine is and isn't
- Show syntax with comparisons to RSpec
- Jasmine with:
- Vanilla JavaScript
- Jasmine with jQuery
- Jasmine with Ruby (not Rails)
- Jasmine with Rails
- Evergreen
- capybara-webkit
- Where does CoffeeScript, node.js, etc. fit in?
- Other helpful libraries/Wrap-up
How Angular2 Can Improve Your AngularJS Apps Today!Nir Kaufman
Are you ready to migrate your Angular1 project to Angular2? through this slides you will discover some tips that can make your current application better and ready for future migration. A link for reference project can be found inside.
Introduction to reactive programming & ReactiveCocoaFlorent Pillet
Reactive programming models asynchronous data streams as signals that produce events over time. ReactiveCocoa is a framework that implements reactive programming in Objective-C. It uses signals to represent asynchronous data streams and operators to transform and combine signals. ReactiveCocoa code separates the logic to produce and consume data, making it more modular, reusable, testable and by reducing state and mutability. While the syntax is different, learning to think reactively can improve code quality and stability.
Angular Performance: Then, Now and the Future. Todd MottoFuture Insights
This document summarizes AngularJS performance features discussed by Todd Motto, a Google Developer Expert and lead engineer at Mozio. The summary includes:
1. Angular 1.2 to 1.3 brought major performance improvements like IE8 support being dropped, DOM manipulation being 4.3 times faster, and the $digest loop being 3.5 times faster.
2. New features in 1.3 like one-time bindings, ngModelOptions, and bindToController help optimize performance.
3. Todd Motto discusses techniques for improving Angular performance like minimizing $watches, using $applyAsync with $http, disabling debug info, and avoiding expensive DOM filters.
4. The
The document discusses RSpec, a behavior-driven development (BDD) framework for testing Ruby code. It describes how RSpec allows writing tests in a natural language style using "should" statements. Examples are provided for different types of RSpec tests, including model, controller, and view tests. Shared examples, custom matchers, and integration with Cucumber for writing tests in a storytelling format are also covered. The document concludes with information on installing and running RSpec and generating reports from test results.
Excellent is a static analysis gem that finds the nasty lines in your code. It implements a comprehensive set of checks for possibly buggy parts of your app that would otherwise make it into your repo and eventually to the production server.
Slides from my Lonestar Ruby Conf 2011 presentation.
*** Video of presentation: http://confreaks.com/videos/2531-lsrc2011-testing-javascript-with-jasmine ***
Agenda:
- Briefly cover why you should unit test
- Discuss what Jasmine is and isn't
- Show syntax with comparisons to RSpec
- Jasmine with:
- Vanilla JavaScript
- Jasmine with jQuery
- Jasmine with Ruby (not Rails)
- Jasmine with Rails
- Evergreen
- capybara-webkit
- Where does CoffeeScript, node.js, etc. fit in?
- Other helpful libraries/Wrap-up
How Angular2 Can Improve Your AngularJS Apps Today!Nir Kaufman
Are you ready to migrate your Angular1 project to Angular2? through this slides you will discover some tips that can make your current application better and ready for future migration. A link for reference project can be found inside.
Introduction to reactive programming & ReactiveCocoaFlorent Pillet
Reactive programming models asynchronous data streams as signals that produce events over time. ReactiveCocoa is a framework that implements reactive programming in Objective-C. It uses signals to represent asynchronous data streams and operators to transform and combine signals. ReactiveCocoa code separates the logic to produce and consume data, making it more modular, reusable, testable and by reducing state and mutability. While the syntax is different, learning to think reactively can improve code quality and stability.
This document provides information about using MapKit and displaying map data in iOS applications. It discusses displaying maps, adding annotations and overlays like polygons and circles, handling gestures, and loading KML data. It includes code snippets in Objective-C for creating map views, annotations, overlays from KML, handling gestures, and displaying annotation views with custom images.
Good karma: UX Patterns and Unit Testing in Angular with KarmaExoLeaders.com
The document discusses unit testing in Angular with Karma. It provides examples of UX patterns in Angular like binding elements to variables, lists, and click handlers. It also covers what controllers and scopes are and examples of testing components in Angular like services, factories, and UI elements. Hands-on examples are provided for setting up a test environment and writing tests.
The document provides an overview of JavaScript fundamentals, common patterns, and an introduction to Node.js. It discusses JavaScript data types and operators, variable scoping, objects and classes. It also covers jQuery optimization techniques like selector caching and event handling. For Node.js, it demonstrates how to create an HTTP server, manage dependencies with npm, build an Express server, and use middleware.
Donner le goût du ReactiveCocoa. L’objectif de la présentation étant de nous expliquer comment migrer du code lié au KVO vers une implémentation ReactiveCocoa. Cette approche du KVO par ReactiveCocoa permet de comprendre très facilement les bases et l’intérêt de ce nouveau framework et de s’y mettre facilement et progressivement.
eact is a library for building HTML user interfaces. It is the "view" in a Model-View-Controller application. Created by the UI wizards at Facebook, top websites like Instagram, Netflix, Airbnb, Bleacher Report and Feedly use it. React is the 6th most starred project on GitHub and grows more popular every day.
In this two-day workshop, we will introduce you to React. On the first day, we will work through a series of increasingly more complicated tutorial exercises. Along the way, we will explain concepts like JSX, immutability, statefulness, one-way data flow, components, and virtual DOM.
With the basics out of the way, we will spend the second-day building a complex application which will put React through its paces and give us a chance to explore most of its features. Then we will learn how to think in React. We will show you how to go from design to components to working application. We will wrap the weekend with a quick preview of React Native, which allows you to use your React skills to create cross-platform mobile apps.
This document discusses JavaScript unit testing with Jasmine. It provides an overview of Jasmine's syntax including describes, contexts, matches, spies and stubs. It also discusses tools that can be used with Jasmine like jasmine-jquery for DOM testing and jasmine-given for behavior-driven development style tests.
Avoiding callback hell in Node js using promisesAnkit Agarwal
This document discusses using promises in Node.js to avoid callback hell. It explains that Node.js is event-based and non-blocking, allowing it to handle multiple requests simultaneously. However, nested callbacks can result in unwieldy callback pyramids or "callback hell". Promises provide a way to write asynchronous code in a more linear way using method chaining. Key benefits include separation of concerns between wrapping asynchronous functions and controlling flow, as well as more readable code. The document provides examples of chaining, nesting, combining, and creating promises using deferred objects in the Q promise library.
The document is a presentation by Clément Sauvage about Realm, a new mobile database. It introduces Realm as being amazingly simple to use, requiring only a few lines of code to instantiate and query. Realm uses object-oriented classes to define schemas and supports common operations like queries, sorting, relations between objects, and migrations between schema versions. The presentation provides examples of adding, querying, and relating objects to demonstrate Realm's ease of use compared to other mobile databases.
This talk was given at JSSummit 2013. Entitled "Avoiding Callback Hell with Async.js", my talk focused on common pitfalls with asynchronous functions and callbacks in JavaScript, and using the async.js library and its advanced control flows to create cleaner, more manageable code.
Workshop JavaScript Testing. Frameworks. Client vs Server Testing. Jasmine. Chai. Nock. Sinon. Spec Runners: Karma. TDD. Code coverage. Building a testable JS app.
Presentado por ing: Raúl Delgado y Mario García
Unit testing JavaScript using Mocha and NodeJosh Mock
This document discusses unit testing JavaScript code using Mocha and Node.js. It covers what unit testing is, why it is important, how to install and use Mocha and Node.js, and how to write testable code and tests. Advanced testing techniques like asynchronous tests, spies, stubs, mocks, fake timers, and testing DOM manipulation with jsdom and jQuery are also explained.
s React.js a library or a framework? In any case, it is a new way of working that represents a revolution in the way of building web projects. It has very particular characteristics that allow us, for instance, to render React code from the server side, or to include React components from Twig tags. During this talk we will present React.js, we will explore how to take advantage of it from PHP projects and we will give answers to practical problems such as universal (isomorphical) rendering and the generation of React.js forms from Symfony forms without duplication of efforts.
This document discusses JavaScript promises and asynchronous programming. It covers how promises represent asynchronous operations as objects, how to chain promises together using .then(), and how promises can be created using the closure or deferred syntax. It also discusses promise terminology, states, error handling, and common promise patterns and use cases. High-order functions and promise utility functions provided by promise libraries are presented. Guidelines for testing promises are also included.
AngularJS with TypeScript and Windows Azure Mobile ServicesRainer Stropek
In the coming two weeks I will do a series of talks at various conferences in Austria and Germany. I will speak about AngularJS, TypeScript, and Windows Azure Mobile Services. In this blog post I publish the slides and the sample code.
Promises provide a consistent way to write asynchronous code in JavaScript by abstracting callbacks into objects. Some key benefits of promises include: handling errors through rejection instead of nested callbacks, ability to chain operations together through promise methods like .then(), and restoring synchronous-like control flow. The document discusses how promises improve on traditional callback-based patterns and provides examples of converting common asynchronous patterns to use promises.
The next version of JavaScript, ES6, is starting to arrive. Many of its features are simple enhancements to the language we already have: things like arrow functions, class syntax, and destructuring. But other features will change the way we program JavaScript, fundamentally expanding the capabilities of the language and reshaping our future codebases. In this talk we'll focus on two of these, discovering the the myriad possibilities of generators and the many tricks you can pull of with template strings.
The document discusses build tools like Ant, Maven, and Gradle. It provides an overview of each tool's history and capabilities. Gradle is presented as a build tool that aims to improve on Ant and Maven by allowing builds to be written in a Groovy-based domain-specific language for improved flexibility. The document also demonstrates several Gradle features like tasks, dependencies, plugins, and multi-project builds.
The document discusses various techniques for optimizing AngularJS (1.x) performance, including:
- Using $watchCollection instead of $watch for large lists
- Tracking by unique identifiers in ng-repeat
- Paginating data with ng-repeat
- Avoiding filters in bindings
- Using one-time bindings
- Debouncing inputs
- Optimizing digest cycles
The presentation emphasizes that premature optimization should be avoided and performance issues addressed only if they truly impact the user experience.
This document provides information about using MapKit and displaying map data in iOS applications. It discusses displaying maps, adding annotations and overlays like polygons and circles, handling gestures, and loading KML data. It includes code snippets in Objective-C for creating map views, annotations, overlays from KML, handling gestures, and displaying annotation views with custom images.
Good karma: UX Patterns and Unit Testing in Angular with KarmaExoLeaders.com
The document discusses unit testing in Angular with Karma. It provides examples of UX patterns in Angular like binding elements to variables, lists, and click handlers. It also covers what controllers and scopes are and examples of testing components in Angular like services, factories, and UI elements. Hands-on examples are provided for setting up a test environment and writing tests.
The document provides an overview of JavaScript fundamentals, common patterns, and an introduction to Node.js. It discusses JavaScript data types and operators, variable scoping, objects and classes. It also covers jQuery optimization techniques like selector caching and event handling. For Node.js, it demonstrates how to create an HTTP server, manage dependencies with npm, build an Express server, and use middleware.
Donner le goût du ReactiveCocoa. L’objectif de la présentation étant de nous expliquer comment migrer du code lié au KVO vers une implémentation ReactiveCocoa. Cette approche du KVO par ReactiveCocoa permet de comprendre très facilement les bases et l’intérêt de ce nouveau framework et de s’y mettre facilement et progressivement.
eact is a library for building HTML user interfaces. It is the "view" in a Model-View-Controller application. Created by the UI wizards at Facebook, top websites like Instagram, Netflix, Airbnb, Bleacher Report and Feedly use it. React is the 6th most starred project on GitHub and grows more popular every day.
In this two-day workshop, we will introduce you to React. On the first day, we will work through a series of increasingly more complicated tutorial exercises. Along the way, we will explain concepts like JSX, immutability, statefulness, one-way data flow, components, and virtual DOM.
With the basics out of the way, we will spend the second-day building a complex application which will put React through its paces and give us a chance to explore most of its features. Then we will learn how to think in React. We will show you how to go from design to components to working application. We will wrap the weekend with a quick preview of React Native, which allows you to use your React skills to create cross-platform mobile apps.
This document discusses JavaScript unit testing with Jasmine. It provides an overview of Jasmine's syntax including describes, contexts, matches, spies and stubs. It also discusses tools that can be used with Jasmine like jasmine-jquery for DOM testing and jasmine-given for behavior-driven development style tests.
Avoiding callback hell in Node js using promisesAnkit Agarwal
This document discusses using promises in Node.js to avoid callback hell. It explains that Node.js is event-based and non-blocking, allowing it to handle multiple requests simultaneously. However, nested callbacks can result in unwieldy callback pyramids or "callback hell". Promises provide a way to write asynchronous code in a more linear way using method chaining. Key benefits include separation of concerns between wrapping asynchronous functions and controlling flow, as well as more readable code. The document provides examples of chaining, nesting, combining, and creating promises using deferred objects in the Q promise library.
The document is a presentation by Clément Sauvage about Realm, a new mobile database. It introduces Realm as being amazingly simple to use, requiring only a few lines of code to instantiate and query. Realm uses object-oriented classes to define schemas and supports common operations like queries, sorting, relations between objects, and migrations between schema versions. The presentation provides examples of adding, querying, and relating objects to demonstrate Realm's ease of use compared to other mobile databases.
This talk was given at JSSummit 2013. Entitled "Avoiding Callback Hell with Async.js", my talk focused on common pitfalls with asynchronous functions and callbacks in JavaScript, and using the async.js library and its advanced control flows to create cleaner, more manageable code.
Workshop JavaScript Testing. Frameworks. Client vs Server Testing. Jasmine. Chai. Nock. Sinon. Spec Runners: Karma. TDD. Code coverage. Building a testable JS app.
Presentado por ing: Raúl Delgado y Mario García
Unit testing JavaScript using Mocha and NodeJosh Mock
This document discusses unit testing JavaScript code using Mocha and Node.js. It covers what unit testing is, why it is important, how to install and use Mocha and Node.js, and how to write testable code and tests. Advanced testing techniques like asynchronous tests, spies, stubs, mocks, fake timers, and testing DOM manipulation with jsdom and jQuery are also explained.
s React.js a library or a framework? In any case, it is a new way of working that represents a revolution in the way of building web projects. It has very particular characteristics that allow us, for instance, to render React code from the server side, or to include React components from Twig tags. During this talk we will present React.js, we will explore how to take advantage of it from PHP projects and we will give answers to practical problems such as universal (isomorphical) rendering and the generation of React.js forms from Symfony forms without duplication of efforts.
This document discusses JavaScript promises and asynchronous programming. It covers how promises represent asynchronous operations as objects, how to chain promises together using .then(), and how promises can be created using the closure or deferred syntax. It also discusses promise terminology, states, error handling, and common promise patterns and use cases. High-order functions and promise utility functions provided by promise libraries are presented. Guidelines for testing promises are also included.
AngularJS with TypeScript and Windows Azure Mobile ServicesRainer Stropek
In the coming two weeks I will do a series of talks at various conferences in Austria and Germany. I will speak about AngularJS, TypeScript, and Windows Azure Mobile Services. In this blog post I publish the slides and the sample code.
Promises provide a consistent way to write asynchronous code in JavaScript by abstracting callbacks into objects. Some key benefits of promises include: handling errors through rejection instead of nested callbacks, ability to chain operations together through promise methods like .then(), and restoring synchronous-like control flow. The document discusses how promises improve on traditional callback-based patterns and provides examples of converting common asynchronous patterns to use promises.
The next version of JavaScript, ES6, is starting to arrive. Many of its features are simple enhancements to the language we already have: things like arrow functions, class syntax, and destructuring. But other features will change the way we program JavaScript, fundamentally expanding the capabilities of the language and reshaping our future codebases. In this talk we'll focus on two of these, discovering the the myriad possibilities of generators and the many tricks you can pull of with template strings.
The document discusses build tools like Ant, Maven, and Gradle. It provides an overview of each tool's history and capabilities. Gradle is presented as a build tool that aims to improve on Ant and Maven by allowing builds to be written in a Groovy-based domain-specific language for improved flexibility. The document also demonstrates several Gradle features like tasks, dependencies, plugins, and multi-project builds.
The document discusses various techniques for optimizing AngularJS (1.x) performance, including:
- Using $watchCollection instead of $watch for large lists
- Tracking by unique identifiers in ng-repeat
- Paginating data with ng-repeat
- Avoiding filters in bindings
- Using one-time bindings
- Debouncing inputs
- Optimizing digest cycles
The presentation emphasizes that premature optimization should be avoided and performance issues addressed only if they truly impact the user experience.
Some common AngularJS anti-patterns include:
- Using jQuery to manipulate the DOM instead of directives
- Checking $scope.$$phase instead of moving $apply calls appropriately
- Not making ng-model bindings objects which can break child scopes
- Creating bloated controllers that do too much like DOM manipulation instead of focusing on data
- Not programming in an "Angular way" by manipulating views instead of models
- Failing to encapsulate third party libraries in Angular services
Gradle combines the power of Ant with the dependency management of Maven. It uses Groovy for its domain specific language to configure and execute builds. Gradle allows defining tasks to customize builds including running tasks in parallel or series based on dependencies. The Android plugin for Gradle integrates Android build configurations and adds tasks for compiling, packaging and testing Android code.
AngularJS performance degrades as the number of watches increases. This document outlines several techniques to optimize AngularJS performance by limiting watches, such as one-way binding, manually triggering filters in controllers instead of templates, lazy loading lists with ng-if instead of ng-show, and removing watches when elements are destroyed. It also discusses measuring performance through tools like Batarang and analyzing the digest cycle duration.
angularjsmeetup-150303044616-conversion-gate01Teo E
AngularJS performance degrades as the number of watches increases. The document discusses several techniques to optimize AngularJS performance by reducing watches, such as one-way binding, manually triggering filters in controllers instead of templates, lazy loading data with infinite scroll, and removing watches on hidden elements. It also recommends limiting DOM manipulation and using built-in tools like ng-if, ng-repeat's track by, and limitTo to avoid unnecessary watches and digest cycles.
2011-02-03 LA RubyConf Rails3 TDD WorkshopWolfram Arnold
This document provides an overview of test-driven development (TDD) using Rails 3. It discusses why TDD is important, how to structure tests in different layers (model, controller, etc.), and what to test for models, controllers and views. It also covers RSpec 2 and useful tools like RVM. The presentation includes live coding demos and in-class exercises on TDD.
An introduction to the complex single page web application framework known as AngularJs. An attempt to overview the high-level aspects of the framework, and to supply references for further exploration.
This document discusses techniques for optimizing AngularJS performance. It begins by explaining how to measure performance using Chrome Dev Tools, Batarang, and console.time. It then discusses minimizing watchers, binding once, using filters and caching, optimizing ng-repeat, ng-model, ng-if vs ng-show, and $$apply vs $$digest. The document provides examples and references for further reading on each topic. It concludes by assigning a homework task to intentionally degrade an application's performance and then optimize it using the techniques described.
The document is a presentation on advanced JavaScript. It covers EcmaScript 5 features like strict mode, which helps detect bad programming practices. Strict mode is enabled by including "use strict" in global or function scope. Other ES5 changes include a native JSON object for parsing and stringifying JSON, and new array methods like indexOf, map, and filter.
This document provides an overview of Angular.JS and advanced Angular.JS concepts. It discusses bootstrapping an Angular app, the main features of Angular including templating, routing, two-way data binding, directives, and dependency injection. It also covers best practices, testing and tooling, SEO considerations for Angular apps, and whether Angular is suitable for enterprise projects. The presenter then demonstrates a bootstrapped Angular app and provides resources for learning more about Angular.
Optimizing AngularJS Application, that include with some useful best practices to in AngularJS. The best practices defined here is well stablished in Angular team itself and developers in community.
gDayX 2013 - Advanced AngularJS - Nicolas EmbletonGeorge Nguyen
This document provides an overview of AngularJS. It begins with introductions and then outlines the agenda which includes bootstrapping, why AngularJS is useful, main features like templating and data binding, best practices, testing and tooling, SEO considerations, and whether it can be used for enterprise projects. It then demonstrates some AngularJS concepts like directives and templating. The document emphasizes AngularJS' reusability, testability, and production readiness while noting best practices are important for complex projects.
The Peanut Butter Cup of Web-dev: Plack and single page web appsJohn Anderson
This document discusses single page web applications and the Angular.js framework. It provides an example of a simple Angular app with two-way data binding between HTML and JavaScript. It also describes how Plack and Perl can be used to prototype and serve such single page apps from the backend during development before integrating a full backend. The document encourages starting simply and learning new techniques gradually.
Dart is a new language for the web, enabling you to write JavaScript on a secure and manageable way. No need to worry about "JavaScript: The bad parts".
This presentation concentrates on the developer experience converting from the Java based GWT to Dart.
This document discusses AngularJS and single page applications (SPAs). It begins by defining what a SPA is - a client-side application that functions like a desktop application with rich and responsive functionality. Technically, SPAs use HTML5 and JavaScript with lightweight REST/JSON services and data binding. AngularJS is introduced as a complete framework for building rich SPAs that hides DOM manipulation and uses data binding instead of direct DOM changes. The document then covers key aspects of AngularJS including directives, views/controllers/scopes, modules/routes/services, and custom directives. It concludes by discussing some UI elements in AngularJS and notes that real-world SPAs often blur the lines between client and server.
This talk discusses various issues of low-level PHP performance, such as: When is it more efficient to use arrays or objects? What causes catastrophic garbage collection? Does adding type annotations make PHP faster or slower?
I will answer these types of question with a (shallow) dive into PHP internals, touching on various topics like value representation, bytecode optimization and GC.
This document provides an overview and agenda for an Advanced Angular.JS training session in Ho Chi Minh City, Vietnam in 2013. The agenda includes introductions, bootstrapping Angular apps, an overview of why Angular is useful, its main features like templating, routing, data binding, directives and dependency injection. It also covers best practices, testing, tooling, SEO considerations and concludes with a note on using Angular for enterprise projects and final words on Angular's maturity. Code examples are provided to demonstrate templating, directives and component communication.
Plack is an interface for web request handlers that simplifies the interface and makes code more portable. It allows developers to focus on request handling rather than API specifics. Plack addresses issues with traditional CGI and mod_perl approaches by running handlers outside of servers in a standardized way. This encapsulation improves performance, debugging, and code reuse across different server implementations. Plack includes modules for common tasks like routing, middleware, and running PSGI applications on various web servers.
Similar to Optimizing a large angular application (ng conf) (20)
DECODING JAVA THREAD DUMPS: MASTER THE ART OF ANALYSISTier1 app
Are you ready to unlock the secrets hidden within Java thread dumps? Join us for a hands-on session where we'll delve into effective troubleshooting patterns to swiftly identify the root causes of production problems. Discover the right tools, techniques, and best practices while exploring *real-world case studies of major outages* in Fortune 500 enterprises. Engage in interactive lab exercises where you'll have the opportunity to troubleshoot thread dumps and uncover performance issues firsthand. Join us and become a master of Java thread dump analysis!
Mobile App Development Company In Noida | Drona InfotechDrona Infotech
Drona Infotech is a premier mobile app development company in Noida, providing cutting-edge solutions for businesses.
Visit Us For : https://www.dronainfotech.com/mobile-application-development/
Microservice Teams - How the cloud changes the way we workSven Peters
A lot of technical challenges and complexity come with building a cloud-native and distributed architecture. The way we develop backend software has fundamentally changed in the last ten years. Managing a microservices architecture demands a lot of us to ensure observability and operational resiliency. But did you also change the way you run your development teams?
Sven will talk about Atlassian’s journey from a monolith to a multi-tenanted architecture and how it affected the way the engineering teams work. You will learn how we shifted to service ownership, moved to more autonomous teams (and its challenges), and established platform and enablement teams.
14 th Edition of International conference on computer visionShulagnaSarkar2
About the event
14th Edition of International conference on computer vision
Computer conferences organized by ScienceFather group. ScienceFather takes the privilege to invite speakers participants students delegates and exhibitors from across the globe to its International Conference on computer conferences to be held in the Various Beautiful cites of the world. computer conferences are a discussion of common Inventions-related issues and additionally trade information share proof thoughts and insight into advanced developments in the science inventions service system. New technology may create many materials and devices with a vast range of applications such as in Science medicine electronics biomaterials energy production and consumer products.
Nomination are Open!! Don't Miss it
Visit: computer.scifat.com
Award Nomination: https://x-i.me/ishnom
Conference Submission: https://x-i.me/anicon
For Enquiry: Computer@scifat.com
E-commerce Development Services- Hornet DynamicsHornet Dynamics
For any business hoping to succeed in the digital age, having a strong online presence is crucial. We offer Ecommerce Development Services that are customized according to your business requirements and client preferences, enabling you to create a dynamic, safe, and user-friendly online store.
Measures in SQL (SIGMOD 2024, Santiago, Chile)Julian Hyde
SQL has attained widespread adoption, but Business Intelligence tools still use their own higher level languages based upon a multidimensional paradigm. Composable calculations are what is missing from SQL, and we propose a new kind of column, called a measure, that attaches a calculation to a table. Like regular tables, tables with measures are composable and closed when used in queries.
SQL-with-measures has the power, conciseness and reusability of multidimensional languages but retains SQL semantics. Measure invocations can be expanded in place to simple, clear SQL.
To define the evaluation semantics for measures, we introduce context-sensitive expressions (a way to evaluate multidimensional expressions that is consistent with existing SQL semantics), a concept called evaluation context, and several operations for setting and modifying the evaluation context.
A talk at SIGMOD, June 9–15, 2024, Santiago, Chile
Authors: Julian Hyde (Google) and John Fremlin (Google)
https://doi.org/10.1145/3626246.3653374
Malibou Pitch Deck For Its €3M Seed Roundsjcobrien
French start-up Malibou raised a €3 million Seed Round to develop its payroll and human resources
management platform for VSEs and SMEs. The financing round was led by investors Breega, Y Combinator, and FCVC.
E-Invoicing Implementation: A Step-by-Step Guide for Saudi Arabian CompaniesQuickdice ERP
Explore the seamless transition to e-invoicing with this comprehensive guide tailored for Saudi Arabian businesses. Navigate the process effortlessly with step-by-step instructions designed to streamline implementation and enhance efficiency.
Consistent toolbox talks are critical for maintaining workplace safety, as they provide regular opportunities to address specific hazards and reinforce safe practices.
These brief, focused sessions ensure that safety is a continual conversation rather than a one-time event, which helps keep safety protocols fresh in employees' minds. Studies have shown that shorter, more frequent training sessions are more effective for retention and behavior change compared to longer, infrequent sessions.
Engaging workers regularly, toolbox talks promote a culture of safety, empower employees to voice concerns, and ultimately reduce the likelihood of accidents and injuries on site.
The traditional method of conducting safety talks with paper documents and lengthy meetings is not only time-consuming but also less effective. Manual tracking of attendance and compliance is prone to errors and inconsistencies, leading to gaps in safety communication and potential non-compliance with OSHA regulations. Switching to a digital solution like Safelyio offers significant advantages.
Safelyio automates the delivery and documentation of safety talks, ensuring consistency and accessibility. The microlearning approach breaks down complex safety protocols into manageable, bite-sized pieces, making it easier for employees to absorb and retain information.
This method minimizes disruptions to work schedules, eliminates the hassle of paperwork, and ensures that all safety communications are tracked and recorded accurately. Ultimately, using a digital platform like Safelyio enhances engagement, compliance, and overall safety performance on site. https://safelyio.com/
Most important New features of Oracle 23c for DBAs and Developers. You can get more idea from my youtube channel video from https://youtu.be/XvL5WtaC20A
INTRODUCTION TO AI CLASSICAL THEORY TARGETED EXAMPLESanfaltahir1010
Image: Include an image that represents the concept of precision, such as a AI helix or a futuristic healthcare
setting.
Objective: Provide a foundational understanding of precision medicine and its departure from traditional
approaches
Role of theory: Discuss how genomics, the study of an organism's complete set of AI ,
plays a crucial role in precision medicine.
Customizing treatment plans: Highlight how genetic information is used to customize
treatment plans based on an individual's genetic makeup.
Examples: Provide real-world examples of successful application of AI such as genetic
therapies or targeted treatments.
Importance of molecular diagnostics: Explain the role of molecular diagnostics in identifying
molecular and genetic markers associated with diseases.
Biomarker testing: Showcase how biomarker testing aids in creating personalized treatment plans.
Content:
• Ethical issues: Examine ethical concerns related to precision medicine, such as privacy, consent, and
potential misuse of genetic information.
• Regulations and guidelines: Present examples of ethical guidelines and regulations in place to safeguard
patient rights.
• Visuals: Include images or icons representing ethical considerations.
Content:
• Ethical issues: Examine ethical concerns related to precision medicine, such as privacy, consent, and
potential misuse of genetic information.
• Regulations and guidelines: Present examples of ethical guidelines and regulations in place to safeguard
patient rights.
• Visuals: Include images or icons representing ethical considerations.
Content:
• Ethical issues: Examine ethical concerns related to precision medicine, such as privacy, consent, and
potential misuse of genetic information.
• Regulations and guidelines: Present examples of ethical guidelines and regulations in place to safeguard
patient rights.
• Visuals: Include images or icons representing ethical considerations.
Real-world case study: Present a detailed case study showcasing the success of precision
medicine in a specific medical scenario.
Patient's journey: Discuss the patient's journey, treatment plan, and outcomes.
Impact: Emphasize the transformative effect of precision medicine on the individual's
health.
Objective: Ground the presentation in a real-world example, highlighting the practical
application and success of precision medicine.
Data challenges: Address the challenges associated with managing large sets of patient data in precision
medicine.
Technological solutions: Discuss technological innovations and solutions for handling and analyzing vast
datasets.
Visuals: Include graphics representing data management challenges and technological solutions.
Objective: Acknowledge the data-related challenges in precision medicine and highlight innovative solutions.
Data challenges: Address the challenges associated with managing large sets of patient data in precision
medicine.
Technological solutions: Discuss technological innovations and solutions
A Comprehensive Guide on Implementing Real-World Mobile Testing Strategies fo...kalichargn70th171
In today's fiercely competitive mobile app market, the role of the QA team is pivotal for continuous improvement and sustained success. Effective testing strategies are essential to navigate the challenges confidently and precisely. Ensuring the perfection of mobile apps before they reach end-users requires thoughtful decisions in the testing plan.
Using Query Store in Azure PostgreSQL to Understand Query PerformanceGrant Fritchey
Microsoft has added an excellent new extension in PostgreSQL on their Azure Platform. This session, presented at Posette 2024, covers what Query Store is and the types of information you can get out of it.
Using Query Store in Azure PostgreSQL to Understand Query Performance
Optimizing a large angular application (ng conf)
1. Optimizing a Large
AngularJS Application
Karl Seamon
Senior Software Engineer, Google
Occasional contributor to AngularJS
2. Topics
● The Problems
● Basics and Best Practices
● Diagnosing performance problems
● Improving performance within AngularJS
3. The Problems: What can make an
Angular app slow?
● Anything that could affect a normal JS app
o Slow DOM
o Single-threaded
o etc
● Inefficient directives
o link vs compile
o $parse vs $eval vs interpolation
● Dirty checking
o Lots of watchers
o Slow watchers
o Too many calls to $apply
4. What does slow mean?
● $apply > 25ms
● Click handler > 100ms
● Show a new page > 1s
o > 10s -> users will give up
o 200ms or less is ideal
5. Directives: compile, link, and
constructor
● When a directive appears inside of a
repeater
o compile is called only once
o link and the constructor are called once per iteration
● When creating directives, try to get as much
work done as possible in the compile step
(or even earlier, in the factory)
● Example
o https://github.com/angular/angular.js/commit/f3a796
e522afdbd3b640d14426edb2fbfab463c5
6. Directives: Transclusion
● For directives that wrap other content
● Allows your directive to $digest its own
scope without causing dirty checks on
bindings in the user-provided contents
7. $digest and $apply
● Angular’s documentation favors $apply
o Simpler to use $apply all the time
o $apply has special error handling that $digest lacks
● So what’s $digest for?
o $apply = $rootScope.$digest + some other stuff
o If you update a child scope s, you can call
s.$digest to dirty-check only that s and its
descendants
9. $watch and $watchCollection, con’t
● $watch has two comparison modes
o referential (default) - quick, shallow comparison
o deep - slow, recurses through objects for a deep
comparison; also makes a deep copy of the watched
value each time it changes
● Avoid deep $watch whenever possible
10. $watchCollection
● new in 1.2, used by ng-repeat
● Goes one level deep into the watched array
or object
● A nice alternative to deep $watch in many
cases
11. ● $interpolate: returns function that evals “a
string {{like}} this”
● $parse: returns function that evals
“an.expression”
● $scope.$eval: evaluates “an.expression”
(using $parse)
$eval, $parse, and $interpolate
12. var parsedExp = $parse(‘exp’);
for (var i = 0; i < 99999; i++) {
parsedExp($scope);
}
$eval, $parse, and $interpolate, con’t
● Better to call $parse once and save the function than to call $eval many times
● $parse is much faster than $interpolate, prefer it when possible
for (var i = 0; i < 99999; i++) {
$scope.$eval(‘exp’);
}
13. Putting it together
myApp.directive(function($parse) {
return {
compile: function(elem, attr) {
var fooExp = $parse(attr.foo),
listExp = $parse(attr.list);
return function link(s, elem) {
s.foo = fooExp(s);
scope.$watchCollection(listExp,
function(list) {
// do something
});
};}};});
myApp.directive(function() {
return {
link: function(s, elem, attr) {
s.foo = scope.$eval(attr.foo);
scope.$watch(attr.list,
function(list) {
// do something
}, true);
}};});
14. $watch only what is needed
Sometimes a deep $watch is needed, but not
for the entire object.
By stripping out irrelevant data, we can make
the comparison much faster.
$scope.$watch(‘listOfBigObjects’,
myHandler, true);
$scope.$watch(function($scope) {
return $scope.listOfBigObjects.
map(function(bigObject) {
return bigObject.foo.
fieldICareAbout;
});
}, myHandler, true);
15. $watch before transforming, not
after
When applying expensive transformations to
input, watch the input itself for changes rather
than the output of the transformation.
Example:
https://github.com/angular/angular.js/commit/e2
068ad426075ac34c06c12e2fac5f594cc81969
16. ng-repeat - track by $index
By default, ng-repeat creates a dom node for
each item and destroys that dom node when
the item is removed.
With track by $index, it will reuse dom nodes.
<div ng-repeat=”item in array”>
I live and die by {{item}}.
<div>
<div ng-repeat=”item in array track by
$index”>
I live until {{array.length}} is
less than {{$index}}.
<div>
17. ng-if vs ng-show
● ng-show hides elements and bindings using
css
● ng-if goes a step further and does not even
create them
o Fewer bindings
o Fewer linkers called at startup
● ng-switch is like ng-if in this respect
18. Not really a Best Practice:
$$postDigest
● $$ means private to Angular, so be aware
that the interface is not stable
● Fires a callback after the current $digest
cycle completes
● Great for updating the dom once after dirty
checking is over
19. Avoiding dirty checking altogether
● Sometimes an expression’s output never
changes, but we dirty check it constantly
● Custom directives to the rescue!
o Bind once at link and ignore digest cycles
o Bind at link and dirty check only on certain events
o https://github.com/kseamon/fast-bind/tree/master/
Implements bind
class, href, if, switch, etc left as an exercise to
the reader
● Or maybe an optional module in 1.3?
20. Diagnosing performance problems:
Tools
● AngularJS Batarang
o Great for identifying which $watchers are causing
problems
● Chrome profiler
o Offers a broader view, but harder to read
● performance.now()
o Provides microsecond resolution for measurements
23. Now use
performance.now()
t = 0; c = 0;
var myFunc = function() {
var d = performance.now();
c++;
// some code
// some more code
t += performance.now() - d;
};
Interpreting profiler output: My
function
24. Interpreting profiler output:
angular.copy & angular.equals
● If you see these in your profile, you probably have some deep $watches
that need to slim down (See Slide 7 and Slide 13)
● Tracking these down is bit tricky - we have to dive into angular.js
window.slowest = 0;
function copy(source, destination, recurse){
if (!recurse) var d = performance.now(), d2;
… copy(source, [], true); …
if (!recurse &&
(d2 = performance.now()) - d > slowest) {
slowest = d2 - d;
console.log(toJson(source), slowest);
console.trace();
}
return destination;
}
25. An incomplete list of recent
improvements to AngularJS
● 1.2.7 emoji-clairvoyance (2014-01-03)
o Scope: limit propagation of $broadcast to scopes that have listeners
for the event (80e7a455)
● 1.2.6 taco-salsafication (2013-12-19)
o compile: add class 'ng-scope' before cloning and other micro-
optimizations (f3a796e5)
o $parse: use a faster path when the number of path parts is low
(f4462319)
● 1.2.5 singularity-expansion (2013-12-13)
o $resource: use shallow copy instead of angular.copy (fcd2a813)
o jqLite: implement and use the empty method in place of html(‘’)
(3410f65e)
● 1.2.4 wormhole-blaster (2013-12-06)
o Scope: short-circuit after dirty-checking last dirty watcher (d070450c)
26. Future improvements AngularJS
● 1.3
o Coalesce asynchronous calls to $apply (#5297)
o Built-in bind-once
● Further future (maybe hopefully)
o $postDigestWatch - A public watcher based on $$postDigest for dom
updates (Also update ng-bind, ng-class, et al to use it) (#5828)
o Watcher deduplication (#5829)
o $apply isolation - Set regions (such as dialogs) for which $apply calls
do not affect the whole page (#5830)
o Your ideas - File a ticket! Write a pull request!
For show a new page, it does not have to be fully loaded at that point, just ready enough to show some content. Showing feedback helps mitigate delays.
Deep watch is enabled by passing true as the third argument to $watch.
This advice is at odds with the previous slide - take it on a case by case basis.
But it will still remove them if the array shrinks.
The dom will still be compiled at startup, so if that is too much, you’ll need to employ a custom directive.
We’ve developed a number of these directives in-house. We hoped to get them open-sourced in time for the conference, but it did not happen. So I made a toy implementation to show off the idea.
The profiler is a good for getting an idea of where your problems lie.
I prefer the top-down tree view with measured time rather than percentages.
Just sort by total time and dig your way down.
So the profiler shows you that one of your functions is slow. Now you can use performance.now() to get more info. You can move these lines around in your function to figure out which part(s) are the culprit.
The output you see from this will vary depending on your data
This list is not comprehensive, see the changelog for more