In Ember.js, routes and templates dictate the architecture of your app. This presentation will talk about why this is, and what tools Ember provides to manage architectural complexity.
Ember applications are built around an MVC model that prescribes Models, Views, Controllers, and Routes for managing persistence, DOM, application state, and URLs. In an ambitious enough app, that model may fail to cover the whole problem space. Fear not, for in this presentation you will learn how to use Ember’s container and dependency features to move beyond MVC, as well as learning how they tie Ember internals together.
Video: http://www.youtube.com/watch?v=iCZUKFNXA0k&feature=youtu.be&t=1h45m59s
Ember.js is a JavaScript framework for building web applications. It provides conventions and architecture to make applications more organized and testable. Key aspects of Ember.js include Ember objects, computed properties, templates powered by Handlebars, routes for navigation, and a data modeling layer using Ember Data. Components are also used to build reusable isolated views. Ember follows a "data down, actions up" pattern where data flows from parent to child components and user actions bubble up through the components.
Testing Ember Apps: Managing DependencyMatthew Beale
Ember has an amazing testing story built upon the fundamentals of encapsulation and OO programming central to the framework. Despite this, every web application will be dependent upon and need to interact with native and network APIs that are hostile: Unreliable, slow, under-documented, and not to be trusted. The challenge in testing Ember applications lies with how to handle these external entities.
This document provides an overview of Ember.js, including its history, core concepts, and key features. Ember.js is a JavaScript MVC framework for building single page web applications. It includes features like classes and instances, computed properties, bindings, observers, routing, and integration with Ember Data for model management. The document discusses Ember's application architecture, run loop, object model, and prototype extensions for arrays, strings, and functions. It also covers views, controllers, templates, routing, and testing in Ember.
Everything You (N)ever Wanted to Know about Testing View ControllersBrian Gesiak
This document discusses testing view controllers in iOS applications. It outlines three key aspects for testing view controllers: 1) Defining a module for the app, 2) Manually triggering view controller lifecycle events, and 3) Accessing view controllers instantiated from a storyboard. The document provides examples of writing tests that instantiate a view controller, trigger viewDidLoad, and assert properties and behaviors. While more difficult than testing model layers, the document argues it is possible and important to test view controllers with the right techniques.
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.
In Ember.js, routes and templates dictate the architecture of your app. This presentation will talk about why this is, and what tools Ember provides to manage architectural complexity.
Ember applications are built around an MVC model that prescribes Models, Views, Controllers, and Routes for managing persistence, DOM, application state, and URLs. In an ambitious enough app, that model may fail to cover the whole problem space. Fear not, for in this presentation you will learn how to use Ember’s container and dependency features to move beyond MVC, as well as learning how they tie Ember internals together.
Video: http://www.youtube.com/watch?v=iCZUKFNXA0k&feature=youtu.be&t=1h45m59s
Ember.js is a JavaScript framework for building web applications. It provides conventions and architecture to make applications more organized and testable. Key aspects of Ember.js include Ember objects, computed properties, templates powered by Handlebars, routes for navigation, and a data modeling layer using Ember Data. Components are also used to build reusable isolated views. Ember follows a "data down, actions up" pattern where data flows from parent to child components and user actions bubble up through the components.
Testing Ember Apps: Managing DependencyMatthew Beale
Ember has an amazing testing story built upon the fundamentals of encapsulation and OO programming central to the framework. Despite this, every web application will be dependent upon and need to interact with native and network APIs that are hostile: Unreliable, slow, under-documented, and not to be trusted. The challenge in testing Ember applications lies with how to handle these external entities.
This document provides an overview of Ember.js, including its history, core concepts, and key features. Ember.js is a JavaScript MVC framework for building single page web applications. It includes features like classes and instances, computed properties, bindings, observers, routing, and integration with Ember Data for model management. The document discusses Ember's application architecture, run loop, object model, and prototype extensions for arrays, strings, and functions. It also covers views, controllers, templates, routing, and testing in Ember.
Everything You (N)ever Wanted to Know about Testing View ControllersBrian Gesiak
This document discusses testing view controllers in iOS applications. It outlines three key aspects for testing view controllers: 1) Defining a module for the app, 2) Manually triggering view controller lifecycle events, and 3) Accessing view controllers instantiated from a storyboard. The document provides examples of writing tests that instantiate a view controller, trigger viewDidLoad, and assert properties and behaviors. While more difficult than testing model layers, the document argues it is possible and important to test view controllers with the right techniques.
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.
Testing view controllers with Quick and NimbleMarcio Klepacz
The document discusses testing view controllers with Quick and Nimble. It provides an example of testing a view controller that presents an app intro screen using behavior-driven development. Specifically, it shows how to arrange the view controller in a testable state, invoke the code being tested, and make assertions about the expected behavior using Quick and Nimble matchers. The tests verify that the app intro is presented if it has not been dismissed before and is dismissed if the dismiss button is tapped, as well as checking that a flag is set correctly. Following the arrange-act-assert pattern and addressing view controller lifecycle issues are emphasized for effective testing.
The document discusses protocol-oriented programming (POP) in Swift. It provides examples of using protocols to define behaviors for views and view controllers. Views can adopt protocols to share shaking animations, while view controllers can retrieve data from any network service that conforms to a Gettable protocol. Tests can inject mock services to test view controller functionality without network calls. The document advocates blending different programming paradigms like POP, OOP and FP to build robust and testable apps.
Value types are at the core of Swift (seriously, mostly everything in the Swift standard library is a value type). But how do you avoid subclassing? That’s where the power of Protocol-Oriented programming comes in. Learn how to structure your code to never subclass (almost) again! Practical everyday examples and ideas for your own code base will be included.
Ember.js - introduction
I have searched for Ember ppt in the internet. Got many things but not like structured... So i have just combined and made a new one..
I am just learning and not an expert. Please share your comments, so i can keep up myself..
This document discusses callbacks, promises, and generators for handling asynchronous code in JavaScript. It begins by explaining callbacks and the issues they can cause like "callback hell". It then introduces promises as an alternative using libraries like Q that allow chaining asynchronous operations together. Generators are also covered as a way to write asynchronous code that looks synchronous when combined with promises through libraries like CO. Overall, it recommends using an asynchronous pattern supported by a library to manage complex asynchronous code.
Ember testing internals with ember cliCory Forsyth
The document discusses Ember testing internals with Ember-CLI. It describes the Ember-CLI test harness which generates tests/index.html and includes vendor JS, test support code, and test modules. It explains how Ember-CLI generates different types of tests and the boilerplate used. It also details how Ember's moduleFor and test functions work to set up isolated containers and handle asynchronous behavior in tests.
Django Celery - A distributed task queueAlex Eftimie
This document introduces django-celery, an open source asynchronous task queue/job queue for Django projects. It discusses how celery allows distributing tasks across multiple workers for parallel processing. Tasks can run independently, in chains, groups or with callbacks. Celery integrates with Django and allows offloading long-running tasks from the main request-response cycle for improved performance. Examples show how celery can be used to parallelize operations like generating PDFs or processing uploaded images.
This document provides an introduction and overview of React and Redux. It begins with an introduction to key React concepts like components, props, state, and the virtual DOM. It then covers Redux, including actions, reducers, stores, and using Redux with React. Other topics include React Native, server-side rendering, routing with React Router, testing, and resources for learning more. The document aims to give the high-level essential information about React and Redux.
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.
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.
Unit testing JavaScript code with Jasmine allows developers to test functionality in isolation through matchers, spies, and asynchronous handling. Key benefits include cheaper QA, better documentation, improved code quality, and easier debugging. While some are deterred by complex asynchronous code or small projects, unit testing pays off through early bug detection and confidence that features work as intended.
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
The document discusses building native components and modules for React Native applications. It provides guidance on creating native modules and components for both iOS and Android platforms. For native modules, it describes how to expose methods and properties to JavaScript. For native components, it explains how to create custom native views and expose their properties and events to React components.
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 provides an overview of using Redux middleware for asynchronous actions, logging, analytics, and authentication. It demonstrates how to structure asynchronous action creators to work with Redux Thunk middleware and make API calls. It also shows how to build custom middleware to handle API requests, add authentication headers, and process responses. The document recommends middleware as a way to separate logic from components and encourages further reading on middleware patterns and the Redux ecosystem.
Backbone.js helps structure you javascript application code in a scalable way.
In this keynote I demonstrate how to use it in a simple walk-through example, and discuss the advantages of using an MVC framework.
This document provides an important notice about final project milestones, links to slides about front end web development (FEWD), instructions for setting up a GitHub repository and copying code files for this week's lesson, and an agenda for reviewing variables, conditionals, functions, and working with arrays and collections of data. Students are instructed to begin writing pseudo code and drafting HTML/CSS for their application and submit it by the end of the 7th week.
The document discusses the technology stack used to build the Wercker platform for continuous deployment. It focuses on key Node.js modules like Express for building APIs, Async for managing asynchronous code, Request for making HTTP requests, and Mongoose for interacting with MongoDB. Examples are provided for how each module is used. Other technologies mentioned include Backbone.js, WebSockets, nodeenv, socket.io, aws2js, and underscore.js.
Testing view controllers with Quick and NimbleMarcio Klepacz
The document discusses testing view controllers with Quick and Nimble. It provides an example of testing a view controller that presents an app intro screen using behavior-driven development. Specifically, it shows how to arrange the view controller in a testable state, invoke the code being tested, and make assertions about the expected behavior using Quick and Nimble matchers. The tests verify that the app intro is presented if it has not been dismissed before and is dismissed if the dismiss button is tapped, as well as checking that a flag is set correctly. Following the arrange-act-assert pattern and addressing view controller lifecycle issues are emphasized for effective testing.
The document discusses protocol-oriented programming (POP) in Swift. It provides examples of using protocols to define behaviors for views and view controllers. Views can adopt protocols to share shaking animations, while view controllers can retrieve data from any network service that conforms to a Gettable protocol. Tests can inject mock services to test view controller functionality without network calls. The document advocates blending different programming paradigms like POP, OOP and FP to build robust and testable apps.
Value types are at the core of Swift (seriously, mostly everything in the Swift standard library is a value type). But how do you avoid subclassing? That’s where the power of Protocol-Oriented programming comes in. Learn how to structure your code to never subclass (almost) again! Practical everyday examples and ideas for your own code base will be included.
Ember.js - introduction
I have searched for Ember ppt in the internet. Got many things but not like structured... So i have just combined and made a new one..
I am just learning and not an expert. Please share your comments, so i can keep up myself..
This document discusses callbacks, promises, and generators for handling asynchronous code in JavaScript. It begins by explaining callbacks and the issues they can cause like "callback hell". It then introduces promises as an alternative using libraries like Q that allow chaining asynchronous operations together. Generators are also covered as a way to write asynchronous code that looks synchronous when combined with promises through libraries like CO. Overall, it recommends using an asynchronous pattern supported by a library to manage complex asynchronous code.
Ember testing internals with ember cliCory Forsyth
The document discusses Ember testing internals with Ember-CLI. It describes the Ember-CLI test harness which generates tests/index.html and includes vendor JS, test support code, and test modules. It explains how Ember-CLI generates different types of tests and the boilerplate used. It also details how Ember's moduleFor and test functions work to set up isolated containers and handle asynchronous behavior in tests.
Django Celery - A distributed task queueAlex Eftimie
This document introduces django-celery, an open source asynchronous task queue/job queue for Django projects. It discusses how celery allows distributing tasks across multiple workers for parallel processing. Tasks can run independently, in chains, groups or with callbacks. Celery integrates with Django and allows offloading long-running tasks from the main request-response cycle for improved performance. Examples show how celery can be used to parallelize operations like generating PDFs or processing uploaded images.
This document provides an introduction and overview of React and Redux. It begins with an introduction to key React concepts like components, props, state, and the virtual DOM. It then covers Redux, including actions, reducers, stores, and using Redux with React. Other topics include React Native, server-side rendering, routing with React Router, testing, and resources for learning more. The document aims to give the high-level essential information about React and Redux.
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.
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.
Unit testing JavaScript code with Jasmine allows developers to test functionality in isolation through matchers, spies, and asynchronous handling. Key benefits include cheaper QA, better documentation, improved code quality, and easier debugging. While some are deterred by complex asynchronous code or small projects, unit testing pays off through early bug detection and confidence that features work as intended.
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
The document discusses building native components and modules for React Native applications. It provides guidance on creating native modules and components for both iOS and Android platforms. For native modules, it describes how to expose methods and properties to JavaScript. For native components, it explains how to create custom native views and expose their properties and events to React components.
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 provides an overview of using Redux middleware for asynchronous actions, logging, analytics, and authentication. It demonstrates how to structure asynchronous action creators to work with Redux Thunk middleware and make API calls. It also shows how to build custom middleware to handle API requests, add authentication headers, and process responses. The document recommends middleware as a way to separate logic from components and encourages further reading on middleware patterns and the Redux ecosystem.
Backbone.js helps structure you javascript application code in a scalable way.
In this keynote I demonstrate how to use it in a simple walk-through example, and discuss the advantages of using an MVC framework.
This document provides an important notice about final project milestones, links to slides about front end web development (FEWD), instructions for setting up a GitHub repository and copying code files for this week's lesson, and an agenda for reviewing variables, conditionals, functions, and working with arrays and collections of data. Students are instructed to begin writing pseudo code and drafting HTML/CSS for their application and submit it by the end of the 7th week.
The document discusses the technology stack used to build the Wercker platform for continuous deployment. It focuses on key Node.js modules like Express for building APIs, Async for managing asynchronous code, Request for making HTTP requests, and Mongoose for interacting with MongoDB. Examples are provided for how each module is used. Other technologies mentioned include Backbone.js, WebSockets, nodeenv, socket.io, aws2js, and underscore.js.
The document describes a mobile app development toolkit called Mulberry that includes:
- A command line interface that creates an app structure with necessary files
- An application framework for JavaScript, HTML templates, and CSS
- A builder that generates production-ready builds for Android and iOS
- Tools for managing routes, components, capabilities, stores, and page definitions to build the app functionality and interface
This document provides tips and tricks for writing Ansible roles, including:
1. It recommends using 'ansible-galaxy init' to automatically generate the directory structure for a role, rather than manually creating files and folders.
2. It describes how to specify role dependencies in the metadata file and how tags and conditionals also apply to dependent roles.
3. It discusses best practices for creating cross-platform roles by using conditionals, includes, and set_facts to target tasks and variables depending on operating system.
This document discusses metaprogramming in JavaScript using ES6 features like proxies. It provides an example of using a proxy to create a domain-specific language that allows chaining method calls like "to(3).double.pow.get", which returns 36. It explains how the proxy intercepts property access and method calls to push functions into a pipeline and execute them on a value. This demonstrates how proxies enable powerful metaprogramming that allows programs to manipulate other programs and representations.
From continuous integration servers to blogging systems, we've all seen and used pluggable applications. Writing our own though can be an elusive task. That need not be the case, though, as the Java EE spec contains all you need to do just that. In this session, we'll see how we can leverage the power of CDI to write, for example, easily extensible JSF applications. When the session is over, you'll have all you need to write the next killer app, and, thanks to Java EE, you'll be surprised to see how little work it really is.
Rails Sojourn: One Man's Journey - Wicked Good Ruby Conference 2013Mike Desjardins
With several spawling, monolithic Rails apps under my belt, I had the opportunity to go a different route. Bulging models, obtuse controllers, and views chock full of logic were my world. When I came up for air, all the cool kids were writing thick clients with svelte backends. Perhaps Sinatra and some hip Javascript framework were the way? Here's what I learned...
This document provides information and instructions for FEWD Week 6. It includes links to slides for the week, instructions for setting up the weekly GitHub repository, and notes on manipulating arrays and collections in JavaScript. It also discusses refactoring code, the "this" keyword, and techniques for debugging code, including using the console, breakpoints, and getting help from others. The agenda covers collecting and manipulating data, arrays, iterating over arrays, refactoring, the "this" keyword, and debugging.
This document provides an overview of dependency injection (DI) and aspect-oriented programming (AOP). It discusses some of the basic problems that DI and AOP aim to address, such as tight coupling between classes and cross-cutting concerns. It provides examples of implementing DI using a service container in Symfony and Google Guice-style annotations. It also demonstrates how AOP can be used for logging and caching through interceptors and pointcuts. Overall, the document introduces key concepts and patterns in DI and AOP through code examples.
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 Angular directives. It defines directives as logic and behavior for the UI that can handle tasks like event handling, template insertion, and data binding. Directives are not where jQuery code goes. The key principles of directives are that they are declarative and model-driven, modular and reusable across contexts by keeping their logic local. The document provides examples of creating a basic directive using a configuration object with a link function, and covers topics like naming conventions, templates, and the restrict and replace properties.
The document discusses Android Loaders, which provide a way for Activities and Fragments to asynchronously load data from a data source and deliver it back without having to manage threads or handle configuration changes. Loaders allow data to persist across configuration changes like orientation changes. The document covers the history of loading data in Android including threads and AsyncTask, introduces Loaders and the LoaderManager API, discusses implementing basic Loaders including CursorLoaders, and covers common mistakes to avoid.
This document provides tips and tricks for using Ansible more effectively. It discusses best practices for inventory structure and variable organization. The key points are:
- Inventory structure and variable organization should make sense for your environment rather than following a "one size fits all" approach. Context is important.
- Variables can be defined in many places like inventory files, group variables, host variables, role defaults etc. and Ansible has a precedence order for variables.
- Playbooks can be made to run tasks in parallel using tools like parallel or by running tasks asynchronously to improve performance for non-serial tasks.
The document describes a solution for providing a unified SOAP/JSON API using Symfony2. It faces the problem that legacy systems use SOAP APIs while mobile devices prefer JSON. The solution is to create a facade API that handles both SOAP and JSON requests, processing them through a common service and returning the appropriate response. It details the key components used to implement the solution like request/response classes and a web service manager.
This document discusses JavaScript code architecture and module patterns using RequireJS. It begins with an introduction to RequireJS and how it can be used to dynamically load modules and their dependencies. Next, it covers defining modules with and without dependencies, and how to return maker functions from modules to create "classes". The document concludes with notes on best practices for modules and an overview of RequireJS configuration options to integrate third-party libraries.
JavaScript is evolving with the addition of modules, platform consistency, and harmony features. Modules allow JavaScript code to be organized and avoid naming collisions. CommonJS and AMD module formats are used widely. Platform consistency is improved through polyfills that mimic future APIs for older browsers. Harmony brings language-level modules and features like destructuring assignment, default parameters, and promises to JavaScript. Traceur compiles Harmony code to existing JavaScript.
Promises are a popular pattern for asynchronous operations in JavaScript, existing in some form in every client-side framework in widespread use today. We'll give a conceptual and practical intro to promises in general, before moving on to talking about how they fit into Angular. If you've ever wondered what exactly $q was about, this is the place to learn!
This document provides instructions for setting up a demonstration of the magic_model_generator gem. It mentions setting up the database.yml file and increasing the font size. It also provides commands for starting the postgres database, generating models from existing tables, and preparing the development environment for the demo.
From the Ember LA meetup in March 2017. This presentation discussed dependency injection in Ember.js as well as the module unification and Glimmer/di projects.
Some demos of Ember DI live-coded during the talk can be found here: https://github.com/mixonic/ember-dependency-injection-demo
Building on the Glimmer rendering engine, Ember continues to make performance and stability dual priorities. Let's discuss what the web looks like in 2017 and how Ember is prepared, and can better prepare, to meet new challenges.
Though component and custom element patterns have become the standard for web application architecture, communicating from one solution to another remains fogged by guesswork and opinion.
How should you write a web component that needs to be compatible with Ember and other frameworks? Where are the tradeoffs between purity of design and ergonomics? In a talk touching on libraries and standards, come learn how to write component code useful across many environments.
For my talk I shared a few recent thoughts about open source communities, how they are influenced by the businesses that adopt their software, and how Ember's priorities can be thought about in 2016. A lot of this talk was inspired by and referenced Larry Wall's essay Diligence, Patience, and Humility (http://www.oreilly.com/openbook/opensources/book/larry.html).
The way JavaScript is standardized and improved is changing this year. Learning how will help you understand why transpilers have become so popular, and why we will likely be using them for a long time.
Ember itself will need to adapt to changes in JavaScript, and we will take a look at how the existing object model might be migrated to a pure EcmaScript solution.
Veteran Ember NYCer Matthew Beale (@mixonic) will talk about the new APIs arriving soon in Ember. He'll cover how he and the rest of the team have implemented block params and bound attributes, and look at how top-level components, attrs, and opt-in two-way binding may look.
This document discusses the history and benefits of Scalable Vector Graphics (SVG) and how SVG rendering has evolved in Ember.js. It explains that SVG was standardized by the W3C in 1998 in response to competing vector formats. Benefits of SVG include small file sizes, arbitrary resolution, and ability to include metadata, links and animation. The document then summarizes the evolution of how Ember renders templates, moving from rendering templates as strings to directly manipulating the DOM with objects like HTMLBars. It discusses challenges of managing namespaces and contexts when rendering templates directly to the DOM.
Ember.js is a new JavaScript framework for building ambitiously complex web applications. Taking lessons from the iOS development platform and other JavaScript frameworks that came before it, Ember embraces the idea that our applications are more alike than they are dissimilar. It encourages coding by convention, testing, and MVC patterns.
Building an app on Parse makes your data available via the Parse REST API. Using that API, ember-cli and Ember-Data, I’ll show you how to get started porting your native app to the mobile web.
The live coded demo is here: http://emberjs.jsbin.com/lizep/7/edit?html,js,output
Snappy Means Happy: Performance in Ember AppsMatthew Beale
Ember is fast. Ember Core is working hard to make Ember even faster. So why does your app drag?
The performance of a single-page app is impacted by the performance characteristics of its foundational parts: Network, Rendering, and JavaScript. Ember provides tools to manage these cornerstones, but with the tradeoff of introducing its own characteristics.
In this talk, we will use the source of real, shipped Ember apps (and of Ember itself) to diagnose, understand, and improve slow interactions. The Chrome developer tools will help us understand slow code paths and identify opportunities for improvement. Along the way, we will learn how parts of Ember work at the macro and micro level and learn how the framework helps us manage performance challenges in a browser environment.
This document describes building a single page application for authentication against multiple third party services like Facebook and Windows Live using OAuth2 and without page reloads. It discusses using an OAuth adapter and service-specific adapters to handle the different OAuth grant types and flows. Key parts of the implementation include injecting a session service, opening authentication as a promise, handling the redirect flow with a popup window, and reading the access token from the hash fragment or popup message.
Dr. Sean Tan, Head of Data Science, Changi Airport Group
Discover how Changi Airport Group (CAG) leverages graph technologies and generative AI to revolutionize their search capabilities. This session delves into the unique search needs of CAG’s diverse passengers and customers, showcasing how graph data structures enhance the accuracy and relevance of AI-generated search results, mitigating the risk of “hallucinations” and improving the overall customer journey.
Cosa hanno in comune un mattoncino Lego e la backdoor XZ?Speck&Tech
ABSTRACT: A prima vista, un mattoncino Lego e la backdoor XZ potrebbero avere in comune il fatto di essere entrambi blocchi di costruzione, o dipendenze di progetti creativi e software. La realtà è che un mattoncino Lego e il caso della backdoor XZ hanno molto di più di tutto ciò in comune.
Partecipate alla presentazione per immergervi in una storia di interoperabilità, standard e formati aperti, per poi discutere del ruolo importante che i contributori hanno in una comunità open source sostenibile.
BIO: Sostenitrice del software libero e dei formati standard e aperti. È stata un membro attivo dei progetti Fedora e openSUSE e ha co-fondato l'Associazione LibreItalia dove è stata coinvolta in diversi eventi, migrazioni e formazione relativi a LibreOffice. In precedenza ha lavorato a migrazioni e corsi di formazione su LibreOffice per diverse amministrazioni pubbliche e privati. Da gennaio 2020 lavora in SUSE come Software Release Engineer per Uyuni e SUSE Manager e quando non segue la sua passione per i computer e per Geeko coltiva la sua curiosità per l'astronomia (da cui deriva il suo nickname deneb_alpha).
GraphSummit Singapore | The Art of the Possible with Graph - Q2 2024Neo4j
Neha Bajwa, Vice President of Product Marketing, Neo4j
Join us as we explore breakthrough innovations enabled by interconnected data and AI. Discover firsthand how organizations use relationships in data to uncover contextual insights and solve our most pressing challenges – from optimizing supply chains, detecting fraud, and improving customer experiences to accelerating drug discoveries.
Securing your Kubernetes cluster_ a step-by-step guide to success !KatiaHIMEUR1
Today, after several years of existence, an extremely active community and an ultra-dynamic ecosystem, Kubernetes has established itself as the de facto standard in container orchestration. Thanks to a wide range of managed services, it has never been so easy to set up a ready-to-use Kubernetes cluster.
However, this ease of use means that the subject of security in Kubernetes is often left for later, or even neglected. This exposes companies to significant risks.
In this talk, I'll show you step-by-step how to secure your Kubernetes cluster for greater peace of mind and reliability.
In his public lecture, Christian Timmerer provides insights into the fascinating history of video streaming, starting from its humble beginnings before YouTube to the groundbreaking technologies that now dominate platforms like Netflix and ORF ON. Timmerer also presents provocative contributions of his own that have significantly influenced the industry. He concludes by looking at future challenges and invites the audience to join in a discussion.
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...SOFTTECHHUB
The choice of an operating system plays a pivotal role in shaping our computing experience. For decades, Microsoft's Windows has dominated the market, offering a familiar and widely adopted platform for personal and professional use. However, as technological advancements continue to push the boundaries of innovation, alternative operating systems have emerged, challenging the status quo and offering users a fresh perspective on computing.
One such alternative that has garnered significant attention and acclaim is Nitrux Linux 3.5.0, a sleek, powerful, and user-friendly Linux distribution that promises to redefine the way we interact with our devices. With its focus on performance, security, and customization, Nitrux Linux presents a compelling case for those seeking to break free from the constraints of proprietary software and embrace the freedom and flexibility of open-source computing.
GraphSummit Singapore | The Future of Agility: Supercharging Digital Transfor...Neo4j
Leonard Jayamohan, Partner & Generative AI Lead, Deloitte
This keynote will reveal how Deloitte leverages Neo4j’s graph power for groundbreaking digital twin solutions, achieving a staggering 100x performance boost. Discover the essential role knowledge graphs play in successful generative AI implementations. Plus, get an exclusive look at an innovative Neo4j + Generative AI solution Deloitte is developing in-house.
UiPath Test Automation using UiPath Test Suite series, part 5DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 5. In this session, we will cover CI/CD with devops.
Topics covered:
CI/CD with in UiPath
End-to-end overview of CI/CD pipeline with Azure devops
Speaker:
Lyndsey Byblow, Test Suite Sales Engineer @ UiPath, Inc.
Observability Concepts EVERY Developer Should Know -- DeveloperWeek Europe.pdfPaige Cruz
Monitoring and observability aren’t traditionally found in software curriculums and many of us cobble this knowledge together from whatever vendor or ecosystem we were first introduced to and whatever is a part of your current company’s observability stack.
While the dev and ops silo continues to crumble….many organizations still relegate monitoring & observability as the purview of ops, infra and SRE teams. This is a mistake - achieving a highly observable system requires collaboration up and down the stack.
I, a former op, would like to extend an invitation to all application developers to join the observability party will share these foundational concepts to build on:
“An Outlook of the Ongoing and Future Relationship between Blockchain Technologies and Process-aware Information Systems.” Invited talk at the joint workshop on Blockchain for Information Systems (BC4IS) and Blockchain for Trusted Data Sharing (B4TDS), co-located with with the 36th International Conference on Advanced Information Systems Engineering (CAiSE), 3 June 2024, Limassol, Cyprus.
TrustArc Webinar - 2024 Global Privacy SurveyTrustArc
How does your privacy program stack up against your peers? What challenges are privacy teams tackling and prioritizing in 2024?
In the fifth annual Global Privacy Benchmarks Survey, we asked over 1,800 global privacy professionals and business executives to share their perspectives on the current state of privacy inside and outside of their organizations. This year’s report focused on emerging areas of importance for privacy and compliance professionals, including considerations and implications of Artificial Intelligence (AI) technologies, building brand trust, and different approaches for achieving higher privacy competence scores.
See how organizational priorities and strategic approaches to data security and privacy are evolving around the globe.
This webinar will review:
- The top 10 privacy insights from the fifth annual Global Privacy Benchmarks Survey
- The top challenges for privacy leaders, practitioners, and organizations in 2024
- Key themes to consider in developing and maintaining your privacy program
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2024/06/building-and-scaling-ai-applications-with-the-nx-ai-manager-a-presentation-from-network-optix/
Robin van Emden, Senior Director of Data Science at Network Optix, presents the “Building and Scaling AI Applications with the Nx AI Manager,” tutorial at the May 2024 Embedded Vision Summit.
In this presentation, van Emden covers the basics of scaling edge AI solutions using the Nx tool kit. He emphasizes the process of developing AI models and deploying them globally. He also showcases the conversion of AI models and the creation of effective edge AI pipelines, with a focus on pre-processing, model conversion, selecting the appropriate inference engine for the target hardware and post-processing.
van Emden shows how Nx can simplify the developer’s life and facilitate a rapid transition from concept to production-ready applications.He provides valuable insights into developing scalable and efficient edge AI solutions, with a strong focus on practical implementation.
UiPath Test Automation using UiPath Test Suite series, part 6DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 6. In this session, we will cover Test Automation with generative AI and Open AI.
UiPath Test Automation with generative AI and Open AI webinar offers an in-depth exploration of leveraging cutting-edge technologies for test automation within the UiPath platform. Attendees will delve into the integration of generative AI, a test automation solution, with Open AI advanced natural language processing capabilities.
Throughout the session, participants will discover how this synergy empowers testers to automate repetitive tasks, enhance testing accuracy, and expedite the software testing life cycle. Topics covered include the seamless integration process, practical use cases, and the benefits of harnessing AI-driven automation for UiPath testing initiatives. By attending this webinar, testers, and automation professionals can gain valuable insights into harnessing the power of AI to optimize their test automation workflows within the UiPath ecosystem, ultimately driving efficiency and quality in software development processes.
What will you get from this session?
1. Insights into integrating generative AI.
2. Understanding how this integration enhances test automation within the UiPath platform
3. Practical demonstrations
4. Exploration of real-world use cases illustrating the benefits of AI-driven test automation for UiPath
Topics covered:
What is generative AI
Test Automation with generative AI and Open AI.
UiPath integration with generative AI
Speaker:
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
5. • Namespaces are good. Less globals, less conflicts.
• Files map to modules. Could be useful!
• Manage dependencies in JS. Better/simpler build pipeline
and re-usability.
Oh, maybe we should use modules….
Modules for JS
Friday, July 12, 13
9. • When do you declare an object un-used?
• What about nested collections of objects?
• How do you reset singletons during tests?
Oh, maybe we should use an Inversion of Control
Container….
Herding objects is hard.
Friday, July 12, 13
11. • Namespaces are good. Less globals, less conflicts.
App.everythingIsNotASolution
• Often, it will be useful to attach a dependency based on
type.
• Knowing and possibly stubbing dependencies in tests
would be nice.
Oh, maybe we should use Dependency Injection….
Dependencies between objects
Friday, July 12, 13
14. • Factories receive instance variables.
• Resolvers find factories.
• Containers manage injections.
Three Components
Friday, July 12, 13
15. 1 var Factory = Ember.Object.extend();
2
3 // Receives instance variables as a new instance.
4 Factory.create(injections);
5
6 // Can receive injections for future instances.
7 Factory.extend(injections);
8
9
10 // Today in Ember, injections are only sent to instances.
11 // Don't worry yourself about this too much, it may change.
Ember Factories
Friday, July 12, 13
16. Ember Resolvers
1 Ember.DefaultResolver = Ember.Object.extend({
2 namespace: null,
3
4 resolve: function(fullName) {
5 var parsedName = this.parseName(fullName);
6
7 // Some magic for specific types, but usually getting to:
8 return this.resolveOther(parsedName);
9 },
10
11 resolveOther: function(parsedName) {
12 var className = classify(parsedName.name) + classify(parsedName.type),
13 factory = get(parsedName.root, className);
14 if (factory) { return factory; }
15 }
16 })
Resolves fullNames like controller:application
Must provide `resolve`
Friday, July 12, 13
17. Ember Containers
1 var container = new Ember.Container();
2
3 container.register('worker:uploader', MyUploader);
4 container.injection('controller', 'uploader', 'worker:uploader');
5
6 container.resolve('worker:uploader'); //=> MyUploader
7 container.lookup('worker:uploader'); //=> instance of MyUploader
8
9 container.lookup('controller:application').get('uploader');
10 //=> same instance of MyUploader
11
12 container.reset();
Friday, July 12, 13
19. In your own app
Thus, `worker` is available on FilePickerController instances
1 var App = Ember.Application.create();
2
3 App.register('worker:uploader', MyUploader);
4 App.inject('controller:filePicker', 'worker', 'worker:uploader');
5
6 // Ah, so simple.
Friday, July 12, 13
20. In Ember Data
1 Ember.onLoad('Ember.Application', function(Application) {
2 Application.initializer({
3 name: "store",
4
5 initialize: function(container, application) {
6 application.register('store:main', application.Store);
7
8 // Eagerly generate the store so defaultStore is populated.
9 // TODO: Do this in a finisher hook
10 container.lookup('store:main');
11 }
12 });
13
14 Application.initializer({
15 name: "injectStore",
16
17 initialize: function(container, application) {
18 application.inject('controller', 'store', 'store:main');
19 application.inject('route', 'store', 'store:main');
20 }
21 });
22 });
Thus, `store` is available on controllers and routes
Friday, July 12, 13
24. In your own app
Thus, `worker` is available on FilePickerController instances
1 var App = Ember.Application.create();
2
3 App.register('worker:uploader', MyUploader);
4 App.inject('controller:filePicker', 'worker', 'worker:uploader');
5
6 // Ah, so simple.
GLOBAL
Flashback to…
Friday, July 12, 13
25. • Namespaces are good. Less globals, less conflicts.
• Files map to modules. Could be useful!
• Manage dependencies in JS. Better/simpler build pipeline
and re-usability.
Oh, maybe we should use modules….
Modules for JS
Flashback to…
Friday, July 12, 13
29. Ember Resolvers
1 Ember.DefaultResolver = Ember.Object.extend({
2 namespace: null,
3
4 resolve: function(fullName) {
5 var parsedName = this.parseName(fullName);
6
7 // Some magic for specific types, but usually getting to:
8 return this.resolveOther(parsedName);
9 },
10
11 resolveOther: function(parsedName) {
12 var className = classify(parsedName.name) + classify(parsedName.type),
13 factory = get(parsedName.root, className);
14 if (factory) { return factory; }
15 }
16 })
Resolves fullNames like controller:application
Must provide `resolve`
Flashback to...
IM
PLIES
APP.SOM
ETHING
Friday, July 12, 13
30. 1 module "appkit/app" {
2 var App = Ember.Application.create();
3
4 import applicationTemplate from "appkit/templates/application";
5 Em.TEMPLATES['application'] = applicationTemplate;
6
7 export default App;
8 // <script type="text/javascript">import App from “appkit/app”;</script>
9 }
10
11 module "appkit/templates/application" {
12 var template = Ember.Handlebars.compile("Howdy Washington!");
13 export default template;
14 }
Quick fix...
But do that for everything? No way.
Friday, July 12, 13
31. • Factories receive instance variables.
• Resolvers find factories.
• Containers manage injections.
Three Components
Flashback to…
OH
HAI
Friday, July 12, 13
32. 80 function resolveOther(parsedName) {
81 var prefix = this.namespace.modulePrefix;
82 Ember.assert('module prefix must be defined', prefix);
83
84 var pluralizedType = typeMap[parsedName.type] || parsedName.type;
85 var name = parsedName.fullNameWithoutType;
86
87 var moduleName = prefix + '/' + pluralizedType + '/' + underscore(name);
88 var module;
89
90 if (define.registry[moduleName]) {
91 module = requireModule(moduleName);
92
93 if (typeof module.create !== 'function') {
94 module = classFactory(module);
95 }
96
97 if (Ember.ENV.LOG_MODULE_RESOLVER){
98 Ember.logger.info('hit', moduleName);
99 }
100
101 return module;
102 } else {
103 if (Ember.ENV.LOG_MODULE_RESOLVER){
104 Ember.logger.info('miss', moduleName);
105 }
106
107 return this._super(parsedName);
108 }
109 }
/vendor/loader.js
Friday, July 12, 13
33. 1 module "appkit/app" {
2 var App = Ember.Application.create();
3 export default App;
4 // <script type="text/javascript">import App from “appkit/app”;</script>
5 }
6
7 module "appkit/templates/application" {
8 var template = Ember.Handlebars.compile("Howdy Washington!");
9 export default template;
10 }
Ember & ES6 modules, no hacks
Friday, July 12, 13
34. • Views
• Controllers
• Templates
• Routes
Today, works with...
Yay, good-guy classes are fetched via containers
Friday, July 12, 13
35. • Some Views
• Models
• Helpers
Today, busted with...
Boo, Scumbag classes are not referenced via the container
Friday, July 12, 13
36. • Subcontainers. Flush only part of the app.
• Singleton controllers live forever. Problem? Feature?
• Ember.Container could become a micro-lib. Uses no
Ember internally.
The future
Friday, July 12, 13