This document provides an overview of routing changes in Rails 3, including:
- Matching routes using "match" instead of "map.connect" and optional segments.
- Namespaces, scopes, and constraints for organizing and restricting routes.
- Default RESTful routes and generating resources.
- Redirects can now be specified as Rack apps or Procs.
- Mounting other Rack endpoints at specific paths.
This document discusses techniques for improving the performance of SproutCore applications. Some key points include:
1. Keeping intermediate state in JavaScript objects rather than the DOM to avoid unnecessary re-renders.
2. Materializing objects from JSON data only when needed to avoid copying large amounts of unused data.
3. Following speed guidelines like minifying files, using a CDN, setting caching headers to optimize delivery of assets to users.
Rails 3 provides a concise overview of changes in Rails 3 including maintaining MVC structure and RESTful routing while improving areas like file structure, block helpers, routing and constraints, ActiveRecord querying, resources routing, and ActionMailer delivery. Key changes include a more Rack-like implementation, chainable ActiveRecord scopes, and pagination and layout support in ActionMailer.
This document provides an overview of jQuery, a JavaScript library for DOM manipulation. It discusses jQuery's CSS selector syntax, methods for manipulating DOM elements and collections, event handling, AJAX support through methods like load() and get(), and how jQuery is extensible through plugins. The document also provides examples of DOM traversal, value retrieval, event binding, and chaining methods.
jQuery Anti-Patterns for Performance & CompressionPaul Irish
The document discusses various jQuery anti-patterns that can negatively impact performance and compression. It describes caching selections, using document fragments to append content outside of loops, avoiding unnecessary re-querying of elements, and leveraging event delegation with delegate() instead of binding individual handlers. The document emphasizes optimizing selector syntax from right to left, avoiding universal selectors, and detaching elements from the DOM when manipulating them to improve speed.
This document discusses jQuery UI and plugins. It provides an overview of jQuery UI classes that can be used to style elements. It also demonstrates several common jQuery UI widgets like buttons, accordions, dialogs, and tabs. The document discusses jQuery UI effects for animations and transitions. It provides tips for identifying good plugins based on aspects like their API, documentation, support, and community. Overall, the document is an introduction to using jQuery UI and evaluating jQuery plugins.
This document describes how to build a bulletin board application in Laravel. It covers setting up the application structure with Blade views and layouts, connecting to a MySQL database to manage users and posts, creating Eloquent models, and building out the controller logic for common actions like registration, login, creating, editing, and deleting posts. Key sections include setting up the MVC framework with routes and controllers, implementing authentication with sessions, and using relationships and pagination for working with related data.
Single Page Web Apps As WordPress Admin Interfaces Using AngularJS & The Word...Caldera Labs
This document discusses using AngularJS to build single page applications for WordPress admin interfaces that use the WordPress REST API. It covers why this approach is beneficial, how to set it up using Angular routing, controllers, factories and HTTP requests to interact with the REST API. Benefits mentioned include making WordPress interfaces more modern and dynamic, empowering others to build plugins in a decentralized way, and the ease of transitioning to software as a service models. The document encourages readers to learn Angular and check out additional resources on the topic.
This document discusses techniques for improving the performance of SproutCore applications. Some key points include:
1. Keeping intermediate state in JavaScript objects rather than the DOM to avoid unnecessary re-renders.
2. Materializing objects from JSON data only when needed to avoid copying large amounts of unused data.
3. Following speed guidelines like minifying files, using a CDN, setting caching headers to optimize delivery of assets to users.
Rails 3 provides a concise overview of changes in Rails 3 including maintaining MVC structure and RESTful routing while improving areas like file structure, block helpers, routing and constraints, ActiveRecord querying, resources routing, and ActionMailer delivery. Key changes include a more Rack-like implementation, chainable ActiveRecord scopes, and pagination and layout support in ActionMailer.
This document provides an overview of jQuery, a JavaScript library for DOM manipulation. It discusses jQuery's CSS selector syntax, methods for manipulating DOM elements and collections, event handling, AJAX support through methods like load() and get(), and how jQuery is extensible through plugins. The document also provides examples of DOM traversal, value retrieval, event binding, and chaining methods.
jQuery Anti-Patterns for Performance & CompressionPaul Irish
The document discusses various jQuery anti-patterns that can negatively impact performance and compression. It describes caching selections, using document fragments to append content outside of loops, avoiding unnecessary re-querying of elements, and leveraging event delegation with delegate() instead of binding individual handlers. The document emphasizes optimizing selector syntax from right to left, avoiding universal selectors, and detaching elements from the DOM when manipulating them to improve speed.
This document discusses jQuery UI and plugins. It provides an overview of jQuery UI classes that can be used to style elements. It also demonstrates several common jQuery UI widgets like buttons, accordions, dialogs, and tabs. The document discusses jQuery UI effects for animations and transitions. It provides tips for identifying good plugins based on aspects like their API, documentation, support, and community. Overall, the document is an introduction to using jQuery UI and evaluating jQuery plugins.
This document describes how to build a bulletin board application in Laravel. It covers setting up the application structure with Blade views and layouts, connecting to a MySQL database to manage users and posts, creating Eloquent models, and building out the controller logic for common actions like registration, login, creating, editing, and deleting posts. Key sections include setting up the MVC framework with routes and controllers, implementing authentication with sessions, and using relationships and pagination for working with related data.
Single Page Web Apps As WordPress Admin Interfaces Using AngularJS & The Word...Caldera Labs
This document discusses using AngularJS to build single page applications for WordPress admin interfaces that use the WordPress REST API. It covers why this approach is beneficial, how to set it up using Angular routing, controllers, factories and HTTP requests to interact with the REST API. Benefits mentioned include making WordPress interfaces more modern and dynamic, empowering others to build plugins in a decentralized way, and the ease of transitioning to software as a service models. The document encourages readers to learn Angular and check out additional resources on the topic.
Single Page Web Applications with CoffeeScript, Backbone and JasminePaulo Ragonha
This document discusses using CoffeeScript, Backbone.js, and Jasmine BDD to build single page web applications. It begins by explaining why CoffeeScript is useful for cleaning up JavaScript code and avoiding errors. It then discusses how Backbone.js provides structure for single page apps by defining models, collections, views and routers. It notes that Backbone works well with CoffeeScript. Finally, it mentions that Jasmine BDD can be used for writing professional tests.
Drupal 8 leverages Assetic for managing Javascript and CSS assets. This library abstracts the headaches of integrating with the burgeoning universe of asset pre-processors and optimization tools available to the modern developer.
The lead developer of Assetic will give a tour of the library and discuss the current state of the project, its strengths, and its weaknesses, and also touch on the future: Assetic 2.0.
Caldera Learn - LoopConf WP API + Angular FTW WorkshopCalderaLearn
The document provides an overview of a workshop on using the WordPress REST API and AngularJS. The workshop will cover REST API fundamentals, building custom REST APIs, unit testing APIs, and getting started with AngularJS by building controllers, templates, services, and factories. Attendees will learn through hands-on examples and code walkthroughs applied to real world projects.
Introduction to AngularJS For WordPress DevelopersCaldera Labs
- AngularJS is a Model-View-Controller framework that can be used to build dynamic single-page applications for WordPress.
- It uses bindings to connect views (HTML) to controllers, allowing real-time updates as data changes. Data binding is done through directives like ng-model, ng-repeat, etc.
- The $http service provides an easy way to connect Angular models to REST APIs, like the WordPress REST API, to fetch and save data from the backend. This allows building apps that interact with WordPress remotely.
- Additional topics covered include using controllers, building reusable components with directives, and ways to customize the WordPress REST API to fit the needs of Angular applications
Things you should know about jQuery JavaScript library. A JavaScript library designed to hide painful cross-browser compatibility issues while presenting a solid, usable, API.
The document summarizes new features and changes to the jQuery event system in version 1.7. Key points include:
- The .on() and .off() methods were introduced to unify event binding, removing confusion from multiple older methods. This improves performance and reduces code size.
- Event delegation was optimized through "quickIs()" to speed up selector matching, improving delegation performance by 2-4x in most browsers.
- Existing event bugs were fixed and the system was overhauled to make events more "hookable" and extensible.
On February 18th, 2010 was O'Reilly's "Exploring Rails 3" online conference and these are Gregg Pollack's slides. They are by no means a complete record of improvements in Rails 3, but they should serve to get your appetite wet.
jQuery Performance Tips and Tricks (2011)Addy Osmani
Today we’re going to take a look at best practices, tips and tricks for improving the performance of your jQuery code. Performance optimization is a crucial aspect of building ‘snappy’ client-side applications and something which all developers using jQuery should bare in mind.
Getting the Most Out of jQuery Widgetsvelveeta_512
The document discusses strategies for building modular widgets in jQuery. It recommends thinking of widgets as small, decoupled components that communicate through events. Components should subscribe to and respond to events from other components, with references only going downward between layers. Each layer consumes events from lower layers and publishes events upward. The document also recommends decorating widget functions to add logging or other functionality.
The document discusses jQuery basics and the DOM. It explains that the DOM is how browsers structure HTML documents into an XML format. jQuery allows selecting elements from the DOM using CSS-style selectors and manipulating them using jQuery functions. Popular uses of jQuery include DOM manipulation, effects, AJAX calls, and building plugins. The document encourages learning more about jQuery through its online documentation.
jQuery is a JavaScript library which allows you to develop solutions with less code, in less time. You can build interactive prototypes for your prospective clients, or take an existing solution and add new dynamic behaviour with little effort.
We will see how jQuery can be used to quickly and concisely apply JavaScript behaviour to your web app. It will cover selectors, Ajax, DOM manipulation and more. The aim: to produce lean unobtrusive JavaScript with jQuery.
Owl JS is a small JavaScript framework for building user interfaces based on XML templates. Some key points about Owl:
1. It uses XML (QWeb) templates that are compiled just-in-time for efficiency.
2. Components are defined as classes that extend a base Component class. The UI is a tree of nested components.
3. It supports modern features like hooks, slots, and stores to manage state and reactivity.
4. The document provides an example of building a to-do list app in Owl to demonstrate how to define components, handle events between them, and manage state. Key aspects covered include extracting sub-components, dependency injection via the "env"
This document provides an introduction to FuncUnit, a JavaScript functional testing framework. It discusses barriers to testing JavaScript applications, how FuncUnit addresses these barriers through its easy to use API and ability to simulate user interactions across browsers. It also provides examples of using FuncUnit to test applications written with jQuery and without page reloads.
The document discusses different patterns for handling asynchronous code in JavaScript: callbacks, promises, and AMD (Asynchronous Module Definition). It outlines issues with nested callbacks and inflexible APIs. Promises and AMD aim to address these by allowing composition of asynchronous operations and defining module dependencies. The document provides examples of implementing PubSub with events, making and piping promises, and using AMD to load dependencies asynchronously. It concludes that callbacks should generally be avoided in favor of promises or AMD for asynchronous code.
1. The document discusses REST (Representational State Transfer) and how it is used in Rails. REST uses HTTP methods like GET, POST, PUT, DELETE to perform CRUD (create, read, update, delete) operations on resources.
2. Rails follows REST principles by using resourceful routing and RESTful controllers with actions that map to HTTP methods. This allows creating clean, semantic URLs and simplifies development.
3. RESTful design in Rails encourages using the same URL structure for related resources. For example, adding comments to an article would use POST /articles/:article_id/comments rather than adding a custom action to the ArticlesController.
This document provides instructions for creating a simple blog using Django. It includes steps to:
1) Set up the Django project and install necessary apps like the admin interface.
2) Create a blog application with a Post model to store blog posts and configure the admin interface to manage posts.
3) Add templates to display list and detail views of posts and enable pagination for post lists.
4) Create a form to allow adding and editing blog posts from the admin and templates.
5) Provide instructions for deleting posts and include a link to download the full code files.
Play Framework and Ruby on Rails are web application frameworks that help developers build web applications. Both frameworks provide tools and libraries for common tasks like routing, database access, templates and more. Some key similarities include using MVC patterns, supporting SQL/NoSQL databases via libraries, and including tools for unit testing and deployment. Some differences are Play uses Scala and Java while Rails uses Ruby, and they have different project structures and ways of handling assets, templates and dependencies. Both aim to help developers build web applications faster with their features and ecosystem of supporting libraries.
Routing in Rails allows defining the URLs that map to controller actions. The document discusses various routing configurations including:
1. Defining a root path for the site to map to a controller action.
2. Generating routes for RESTful resources like pages and namespaced admin pages.
3. Nesting resources so comments are nested under pages.
4. Adding custom routes mapped to actions on collections or members.
Single Page Web Applications with CoffeeScript, Backbone and JasminePaulo Ragonha
This document discusses using CoffeeScript, Backbone.js, and Jasmine BDD to build single page web applications. It begins by explaining why CoffeeScript is useful for cleaning up JavaScript code and avoiding errors. It then discusses how Backbone.js provides structure for single page apps by defining models, collections, views and routers. It notes that Backbone works well with CoffeeScript. Finally, it mentions that Jasmine BDD can be used for writing professional tests.
Drupal 8 leverages Assetic for managing Javascript and CSS assets. This library abstracts the headaches of integrating with the burgeoning universe of asset pre-processors and optimization tools available to the modern developer.
The lead developer of Assetic will give a tour of the library and discuss the current state of the project, its strengths, and its weaknesses, and also touch on the future: Assetic 2.0.
Caldera Learn - LoopConf WP API + Angular FTW WorkshopCalderaLearn
The document provides an overview of a workshop on using the WordPress REST API and AngularJS. The workshop will cover REST API fundamentals, building custom REST APIs, unit testing APIs, and getting started with AngularJS by building controllers, templates, services, and factories. Attendees will learn through hands-on examples and code walkthroughs applied to real world projects.
Introduction to AngularJS For WordPress DevelopersCaldera Labs
- AngularJS is a Model-View-Controller framework that can be used to build dynamic single-page applications for WordPress.
- It uses bindings to connect views (HTML) to controllers, allowing real-time updates as data changes. Data binding is done through directives like ng-model, ng-repeat, etc.
- The $http service provides an easy way to connect Angular models to REST APIs, like the WordPress REST API, to fetch and save data from the backend. This allows building apps that interact with WordPress remotely.
- Additional topics covered include using controllers, building reusable components with directives, and ways to customize the WordPress REST API to fit the needs of Angular applications
Things you should know about jQuery JavaScript library. A JavaScript library designed to hide painful cross-browser compatibility issues while presenting a solid, usable, API.
The document summarizes new features and changes to the jQuery event system in version 1.7. Key points include:
- The .on() and .off() methods were introduced to unify event binding, removing confusion from multiple older methods. This improves performance and reduces code size.
- Event delegation was optimized through "quickIs()" to speed up selector matching, improving delegation performance by 2-4x in most browsers.
- Existing event bugs were fixed and the system was overhauled to make events more "hookable" and extensible.
On February 18th, 2010 was O'Reilly's "Exploring Rails 3" online conference and these are Gregg Pollack's slides. They are by no means a complete record of improvements in Rails 3, but they should serve to get your appetite wet.
jQuery Performance Tips and Tricks (2011)Addy Osmani
Today we’re going to take a look at best practices, tips and tricks for improving the performance of your jQuery code. Performance optimization is a crucial aspect of building ‘snappy’ client-side applications and something which all developers using jQuery should bare in mind.
Getting the Most Out of jQuery Widgetsvelveeta_512
The document discusses strategies for building modular widgets in jQuery. It recommends thinking of widgets as small, decoupled components that communicate through events. Components should subscribe to and respond to events from other components, with references only going downward between layers. Each layer consumes events from lower layers and publishes events upward. The document also recommends decorating widget functions to add logging or other functionality.
The document discusses jQuery basics and the DOM. It explains that the DOM is how browsers structure HTML documents into an XML format. jQuery allows selecting elements from the DOM using CSS-style selectors and manipulating them using jQuery functions. Popular uses of jQuery include DOM manipulation, effects, AJAX calls, and building plugins. The document encourages learning more about jQuery through its online documentation.
jQuery is a JavaScript library which allows you to develop solutions with less code, in less time. You can build interactive prototypes for your prospective clients, or take an existing solution and add new dynamic behaviour with little effort.
We will see how jQuery can be used to quickly and concisely apply JavaScript behaviour to your web app. It will cover selectors, Ajax, DOM manipulation and more. The aim: to produce lean unobtrusive JavaScript with jQuery.
Owl JS is a small JavaScript framework for building user interfaces based on XML templates. Some key points about Owl:
1. It uses XML (QWeb) templates that are compiled just-in-time for efficiency.
2. Components are defined as classes that extend a base Component class. The UI is a tree of nested components.
3. It supports modern features like hooks, slots, and stores to manage state and reactivity.
4. The document provides an example of building a to-do list app in Owl to demonstrate how to define components, handle events between them, and manage state. Key aspects covered include extracting sub-components, dependency injection via the "env"
This document provides an introduction to FuncUnit, a JavaScript functional testing framework. It discusses barriers to testing JavaScript applications, how FuncUnit addresses these barriers through its easy to use API and ability to simulate user interactions across browsers. It also provides examples of using FuncUnit to test applications written with jQuery and without page reloads.
The document discusses different patterns for handling asynchronous code in JavaScript: callbacks, promises, and AMD (Asynchronous Module Definition). It outlines issues with nested callbacks and inflexible APIs. Promises and AMD aim to address these by allowing composition of asynchronous operations and defining module dependencies. The document provides examples of implementing PubSub with events, making and piping promises, and using AMD to load dependencies asynchronously. It concludes that callbacks should generally be avoided in favor of promises or AMD for asynchronous code.
1. The document discusses REST (Representational State Transfer) and how it is used in Rails. REST uses HTTP methods like GET, POST, PUT, DELETE to perform CRUD (create, read, update, delete) operations on resources.
2. Rails follows REST principles by using resourceful routing and RESTful controllers with actions that map to HTTP methods. This allows creating clean, semantic URLs and simplifies development.
3. RESTful design in Rails encourages using the same URL structure for related resources. For example, adding comments to an article would use POST /articles/:article_id/comments rather than adding a custom action to the ArticlesController.
This document provides instructions for creating a simple blog using Django. It includes steps to:
1) Set up the Django project and install necessary apps like the admin interface.
2) Create a blog application with a Post model to store blog posts and configure the admin interface to manage posts.
3) Add templates to display list and detail views of posts and enable pagination for post lists.
4) Create a form to allow adding and editing blog posts from the admin and templates.
5) Provide instructions for deleting posts and include a link to download the full code files.
Play Framework and Ruby on Rails are web application frameworks that help developers build web applications. Both frameworks provide tools and libraries for common tasks like routing, database access, templates and more. Some key similarities include using MVC patterns, supporting SQL/NoSQL databases via libraries, and including tools for unit testing and deployment. Some differences are Play uses Scala and Java while Rails uses Ruby, and they have different project structures and ways of handling assets, templates and dependencies. Both aim to help developers build web applications faster with their features and ecosystem of supporting libraries.
Routing in Rails allows defining the URLs that map to controller actions. The document discusses various routing configurations including:
1. Defining a root path for the site to map to a controller action.
2. Generating routes for RESTful resources like pages and namespaced admin pages.
3. Nesting resources so comments are nested under pages.
4. Adding custom routes mapped to actions on collections or members.
The document discusses best practices for building web applications using the Ruby on Rails framework. It covers topics like asset pipeline for concatenating and minifying assets, CoffeeScript and SASS for high-level languages, content negotiation for different formats, partials for view components, AJAX, caching, and solving the N+1 query problem through includes and batch loading.
iPhone applications can often benefit by talking to a web service to synchronize data or share information with a community. Ruby on Rails, with its RESTful conventions, is an ideal backend for iPhone applications. In this session you'll learn how to use ObjectiveResource in an iPhone application to interact with a RESTful web service implemented in Rails. This session isn't about how to build web applications that are served up on the iPhone. It's about how to build iPhone applications with a native look and feel that happen to talk to Rails applications under the hood. The upshot is a user experience that transcends the device.
This document provides instructions for using the ECOS framework to build and manage web applications. It discusses creating a sample "notebook" application using ECOS commands like install, update, and createproject. It also covers concepts like the MVC pattern, database schema definition, controllers, models, views, services, and extensions. The document demonstrates how to add features to the notebook app like user avatars, logging, and notifications as reusable services and extensions.
Play 2.0 is a web framework for Java and Scala that is designed to be productive, asynchronous, and reactive. Some key features include being full stack, high-productive, asynchronous and reactive, stateless, HTTP-centric, typesafe, scalable, and open source. Play 2.0 aims to be fun and fast to develop with by enabling features like hot code reloading, browser error reporting, and easy deployment to platforms like Heroku. It also focuses on being asynchronous and reactive through support for WebSockets, Comet, HTTP streaming responses, and composable streams.
Rails 4.0 introduced the following changes:
1. Thread safety is enabled by default.
2. Strong Parameters were added for mass assignment protection.
3. Turbolinks was added to speed up page loads by preventing full page reloads.
4. Russian Doll Caching was introduced to maximize cache hits by nesting fragment caches.
Some features were extracted to gems including Action and Page Caching, Active Resource, and AR Observer. The deprecation policy removes deprecated features in future versions. Strong Parameters replace attr_accessible. Turbolinks improves performance. Russian Doll Caching optimizes caching.
This document discusses using layouts and partials in a Ruby on Rails application. It demonstrates how to create a new layout file, assign it to a controller action, and use content_for and partials to include common elements like menus and footers across views. Code examples are provided for setting up the layouts, partials and integrating them using yield and content_for. The document also covers configuring stylesheets and JavaScript includes for the layouts.
Burn down the silos! Helping dev and ops gel on high availability websitesLindsay Holmwood
HA websites are where the rubber meets the road - at 200km/h. Traditional separation of dev and ops just doesn't cut it.
Everything is related to everything. Code relies on performant and resilient infrastructure, but highly performant infrastructure will only get a poorly written application so far. Worse still, root cause analysis in HA sites will more often than not identify problems that don't clearly belong to either devs or ops.
The two options are collaborate or die.
This talk will introduce 3 core principles for improving collaboration between operations and development teams: consistency, repeatability, and visibility. These principles will be investigated with real world case studies and associated technologies audience members can start using now. In particular, there will be a focus on:
- fast provisioning of test environments with configuration management
- reliable and repeatable automated deployments
- application and infrastructure visibility with statistics collection, logging, and visualisation
All I Need to Know I Learned by Writing My Own Web FrameworkBen Scofield
Ben Scofield gave a talk at Rubyconf about building his own web framework called Athena from scratch. He discussed how starting small with a "Hello World" program and building up from there helped him learn about aspects of web development like RESTful design, routing, ORM/database integration, and exception handling in Ruby. He concluded by noting that there is always more to learn, and shared his GitHub page where the framework code can be found.
And the Greatest of These Is ... Rack SupportBen Scofield
The document discusses Rack, a Ruby web server interface. It begins by explaining Rack's basic request/response cycle and common middleware components like Rack::Cache. It then covers integrating Rack into Rails applications and building custom middleware for tasks like exception handling and progressive caching. The document concludes by discussing some advanced Rack techniques and tools.
QConSP 2015 - Dicas de Performance para Aplicações WebFabio Akita
Antes de pensar em "vamos reescrever tudo na linguagem mais rápida da moda que tudo vai dar certo". Na verdade pra quase todas as aplicações Web, antes veja se você segue este checklist mínimo de 9 dicas. Você vai ver que a maioria não segue esse mínimo antes, e deveria.
Turbocharge your web development with Rails
Vagmi Mudumbai presented an overview of Ruby on Rails web development. The presentation covered installing Ruby and Rails, the MVC framework, generating models and migrations, querying the database, controllers and routes, views and forms. Attendees learned the basics of building a Rails application including setting up models, controllers and views to create, read, update and delete data through a RESTful interface.
Kicking off with Zend Expressive and Doctrine ORM (PHP UK 2017)James Titcumb
You've heard of Zend's new framework, Expressive, and you've heard it's the new hotness. In this talk, I will introduce the concepts of Expressive, how to bootstrap a simple application with the framework using best practices, and finally how to integrate a third party tool like Doctrine ORM.
Mojolicious is a real-time web framework for Perl that provides a simplified single file mode through Mojolicious::Lite. It has a clean, portable, object oriented API without hidden magic. It supports HTTP, WebSockets, TLS, IPv6 and more. Templates can use embedded Perl and are automatically rendered. Helpers, sessions, routing and testing utilities are built in. The generator can create new app structures and components.
As present at FluentConf 2014 on March 11th, 2014.
AngularJS is one of the most popular, and powerful, JavaScript frameworks for building rich client-side applications. AngularJS is both simultaneously both simple to use and extremely full featured. With AngularJS a little goes a long way, but to make the most of it, you need to know what you’re doing.
In this workshop we will build a complex application to help exercise all of the salient points of the AngularJS framework.
Topics covered include, ngResource, directives, fitlers, routing, templates, controllers, testing, and more.
Code can be found at: https://github.com/markbates/fluent-2014
The world of JavaScript client-side frameworks is overflowing with contenders vying for the crown, but which one do you choose for your next project? Which one has what it takes?
In this talk we’ll look at the “Big 3”, AngularJS, Ember.js, and Backbone.js. We’ll compare them head to head, toe to toe. We’ll look at the pros and cons of each one. How do they handle form bindings? Talking to APIs? Code organization? Routing? Etc?
Who’ll come out victorious in this battle of the JavaScript frameworks, or will we all just come out bloodied and bruised on the other side? Guess we’ll find out!
Using and scaling Rack and Rack-based middlewareAlona Mekhovova
Rack provides a standard interface between web servers and web applications. It allows a web application to return a status, headers, and a body in response to an HTTP request. Middleware can be plugged into a Rack application to modify requests and responses. Popular Rack middleware includes Rack::Cache, Rack::Middleware, and Warden for authentication. In Rails, middleware is configured through an initializer and plugged into the middleware stack to run before or after other middleware.
Kicking off with Zend Expressive and Doctrine ORM (Sunshine PHP 2017)James Titcumb
You've heard of Zend's new framework, Expressive, and you've heard it's the new hotness. In this talk, I will introduce the concepts of Expressive, how to bootstrap a simple application with the framework using best practices, and finally how to integrate a third party tool like Doctrine ORM.
Roundup of what is on the web at regarding Rails 3 as of Easter 2010.
Includes outline of significant changes to Rais in Rails 3 plus how you might set about upgrading an existing app.
Acknowledges and links to to some amazing resources already elsewhere on the web.
Writing Fast Client-Side Code: Lessons Learned from SproutCoreYehuda Katz
The SproutCore framework has evolved over the past five years to be an extremely high-performance framework that focuses on making it possible to build native-like applications in the browser.
This means handling problems like working with extremely large data-sets, inconsistent connectivity, and complex DOMs. Lately, it has meant figuring out how to properly use new browser features that can make a big difference to perceived performance, like hardware acceleration.
In this talk, Yehuda will cover some of the techniques that SproutCore has used historically to enable extremely complex applications to perform well in the browser, as well as what new technologies the team is looking at to leverage the latest browser technologies in building compelling content for the web.
The document discusses the benefits of using a framework like SproutCore for building large, complex web applications. It outlines how SproutCore separates an application into distinct Models, Views, and Controllers. Models manage the application data, Views handle DOM manipulation and display, and Controllers tie everything together. This isolation of concerns makes the code more modular and reusable, preventing views from becoming tangled together ("spaghetti code"). The document provides an example of how SproutCore implements a Twitter-like following feature with isolated, reusable Views, Models, and bindings between them to update automatically on data changes.
The document discusses why object-oriented jQuery code should be avoided. It recommends using an event-driven approach instead, where components trigger events to communicate rather than calling methods directly. This fits more cleanly with asynchronous requirements and how users typically interact with elements like autocompleters. The document provides an example of building tab functionality in an event-driven way by binding to click and keypress events that trigger a tabactivate event.
The document discusses why object-oriented jQuery code should be avoided. It recommends using an event-driven approach instead, where components trigger events to communicate rather than calling methods directly. This fits more cleanly with asynchronous requirements and how users typically interact with elements like autocompleters. The document provides an example of building tab functionality in an event-driven way by binding to click and keypress events that trigger a tabactivate event.
Making your oss project more like railsYehuda Katz
This document contains summaries of discussions about open source software projects. Some key points discussed include optimizing for developer happiness initially even if it locks users in, the importance of early adoption to stress test software, and allowing different contributors to care about different aspects of a project rather than just what the original creator cares about. Commercial activity is seen as growing the ecosystem.
The document discusses the evolution of the Rails framework from version 3 to the present. It describes how Rails 3 transitioned from being vaporware to becoming fully featured and stable. It provides examples of how ActiveSupport and ActionController were modularized with clear dependencies between components like ActionDispatch, AbstractController, and ActionController. The document also shows the organization of files within different Rails components and how rendering works in ActionController.
The document discusses the Merb 2.0 framework. It covers core Merb principles like performance and concurrency. It shows how to build Rack-based applications in Merb and ensure they are thread-safe. Modularity is achieved through managing dependencies with specific gem versions. Charts show Merb's concurrency on different Ruby implementations and web servers.
This document discusses test-driven development (TDD) in Merb applications. It emphasizes that tests should focus on the essential functionality and behavior that the developer cares about, rather than implementation details. Tests should continue passing even as the code is refactored. The document provides examples of refactoring code while keeping tests passing. It also suggests ways to make testing easier, such as adding helper methods to simplify request assertions and maintain test session state.
The document discusses different approaches to handling JavaScript and AJAX functionality in Rails applications. It begins by showing how to use Rails' remote_form_for helper to generate JavaScript and AJAX code inline. It then demonstrates how to handle AJAX requests by binding JavaScript directly. The document also explores using JSON to return data from the server and the RJS format for generating JavaScript responses. Overall it provides examples of incrementally moving away from Rails' default JavaScript handling towards binding JavaScript directly.
The document discusses the performance of Ruby and Rails frameworks. While Ruby is acknowledged to be a slower language, several contributors note that performance improvements are underway and hardware continues to get faster. Merb 2.0 is presented as focusing on modularity, integration, and rapid prototyping. Contributors are thanked for their work on Merb.
This document provides an overview of the Merb web framework. Some key points:
- Merb emphasizes efficiency and hackability over being a complete monolithic framework
- It aims to have minimal footprint to give apps more system resources
- It is based on Rack and allows interaction with various web servers
- Merb includes routing, request handling, and rendering functionality
- Mailing functionality is also included and mailers work similarly to controllers
- The modularity of Merb allows flexibility in customizing various aspects
This document provides an overview of DataMapper, an object-relational mapper (ORM) library for Ruby applications. It summarizes DataMapper's main features such as associations, migrations, database adapters, naming conventions, validations, custom types and stores. The document also provides examples of how to use DataMapper with different databases, import/export data, and validate models for specific contexts.
The document discusses how to integrate jQuery and JavaScript functionality into Ruby on Rails and Merb web applications. Key points include:
- Rails and Merb do not have built-in helpers for jQuery, but jQuery is easy to use and Ruby helpers can be written to support it
- The frameworks produce consistent markup that jQuery code can be written to add interactive behavior to
- Options like metadata can be passed to jQuery plugins via the markup generated by helpers
- Helpers, jQuery code, and techniques like the <base> tag allow JavaScript features to be unobtrusively integrated into the MVC frameworks
jQuery Presentation to Rails DevelopersYehuda Katz
This document summarizes jQuery, an open-source JavaScript library that simplifies HTML and JavaScript interactions. It discusses jQuery's features like DOM manipulation, events, effects, and AJAX capabilities. It also covers how to use jQuery with Ruby on Rails, including responding to Ajax requests and placing JavaScript code. The document advocates separating JavaScript behavior from HTML/CSS for maintainability.
Digital Banking in the Cloud: How Citizens Bank Unlocked Their MainframePrecisely
Inconsistent user experience and siloed data, high costs, and changing customer expectations – Citizens Bank was experiencing these challenges while it was attempting to deliver a superior digital banking experience for its clients. Its core banking applications run on the mainframe and Citizens was using legacy utilities to get the critical mainframe data to feed customer-facing channels, like call centers, web, and mobile. Ultimately, this led to higher operating costs (MIPS), delayed response times, and longer time to market.
Ever-changing customer expectations demand more modern digital experiences, and the bank needed to find a solution that could provide real-time data to its customer channels with low latency and operating costs. Join this session to learn how Citizens is leveraging Precisely to replicate mainframe data to its customer channels and deliver on their “modern digital bank” experiences.
AppSec PNW: Android and iOS Application Security with MobSFAjin Abraham
Mobile Security Framework - MobSF is a free and open source automated mobile application security testing environment designed to help security engineers, researchers, developers, and penetration testers to identify security vulnerabilities, malicious behaviours and privacy concerns in mobile applications using static and dynamic analysis. It supports all the popular mobile application binaries and source code formats built for Android and iOS devices. In addition to automated security assessment, it also offers an interactive testing environment to build and execute scenario based test/fuzz cases against the application.
This talk covers:
Using MobSF for static analysis of mobile applications.
Interactive dynamic security assessment of Android and iOS applications.
Solving Mobile app CTF challenges.
Reverse engineering and runtime analysis of Mobile malware.
How to shift left and integrate MobSF/mobsfscan SAST and DAST in your build pipeline.
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2024/06/temporal-event-neural-networks-a-more-efficient-alternative-to-the-transformer-a-presentation-from-brainchip/
Chris Jones, Director of Product Management at BrainChip , presents the “Temporal Event Neural Networks: A More Efficient Alternative to the Transformer” tutorial at the May 2024 Embedded Vision Summit.
The expansion of AI services necessitates enhanced computational capabilities on edge devices. Temporal Event Neural Networks (TENNs), developed by BrainChip, represent a novel and highly efficient state-space network. TENNs demonstrate exceptional proficiency in handling multi-dimensional streaming data, facilitating advancements in object detection, action recognition, speech enhancement and language model/sequence generation. Through the utilization of polynomial-based continuous convolutions, TENNs streamline models, expedite training processes and significantly diminish memory requirements, achieving notable reductions of up to 50x in parameters and 5,000x in energy consumption compared to prevailing methodologies like transformers.
Integration with BrainChip’s Akida neuromorphic hardware IP further enhances TENNs’ capabilities, enabling the realization of highly capable, portable and passively cooled edge devices. This presentation delves into the technical innovations underlying TENNs, presents real-world benchmarks, and elucidates how this cutting-edge approach is positioned to revolutionize edge AI across diverse applications.
Introduction of Cybersecurity with OSS at Code Europe 2024Hiroshi SHIBATA
I develop the Ruby programming language, RubyGems, and Bundler, which are package managers for Ruby. Today, I will introduce how to enhance the security of your application using open-source software (OSS) examples from Ruby and RubyGems.
The first topic is CVE (Common Vulnerabilities and Exposures). I have published CVEs many times. But what exactly is a CVE? I'll provide a basic understanding of CVEs and explain how to detect and handle vulnerabilities in OSS.
Next, let's discuss package managers. Package managers play a critical role in the OSS ecosystem. I'll explain how to manage library dependencies in your application.
I'll share insights into how the Ruby and RubyGems core team works to keep our ecosystem safe. By the end of this talk, you'll have a better understanding of how to safeguard your code.
Connector Corner: Seamlessly power UiPath Apps, GenAI with prebuilt connectorsDianaGray10
Join us to learn how UiPath Apps can directly and easily interact with prebuilt connectors via Integration Service--including Salesforce, ServiceNow, Open GenAI, and more.
The best part is you can achieve this without building a custom workflow! Say goodbye to the hassle of using separate automations to call APIs. By seamlessly integrating within App Studio, you can now easily streamline your workflow, while gaining direct access to our Connector Catalog of popular applications.
We’ll discuss and demo the benefits of UiPath Apps and connectors including:
Creating a compelling user experience for any software, without the limitations of APIs.
Accelerating the app creation process, saving time and effort
Enjoying high-performance CRUD (create, read, update, delete) operations, for
seamless data management.
Speakers:
Russell Alfeche, Technology Leader, RPA at qBotic and UiPath MVP
Charlie Greenberg, host
How to Interpret Trends in the Kalyan Rajdhani Mix Chart.pdfChart Kalyan
A Mix Chart displays historical data of numbers in a graphical or tabular form. The Kalyan Rajdhani Mix Chart specifically shows the results of a sequence of numbers over different periods.
HCL Notes and Domino License Cost Reduction in the World of DLAUpanagenda
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-and-domino-license-cost-reduction-in-the-world-of-dlau/
The introduction of DLAU and the CCB & CCX licensing model caused quite a stir in the HCL community. As a Notes and Domino customer, you may have faced challenges with unexpected user counts and license costs. You probably have questions on how this new licensing approach works and how to benefit from it. Most importantly, you likely have budget constraints and want to save money where possible. Don’t worry, we can help with all of this!
We’ll show you how to fix common misconfigurations that cause higher-than-expected user counts, and how to identify accounts which you can deactivate to save money. There are also frequent patterns that can cause unnecessary cost, like using a person document instead of a mail-in for shared mailboxes. We’ll provide examples and solutions for those as well. And naturally we’ll explain the new licensing model.
Join HCL Ambassador Marc Thomas in this webinar with a special guest appearance from Franz Walder. It will give you the tools and know-how to stay on top of what is going on with Domino licensing. You will be able lower your cost through an optimized configuration and keep it low going forward.
These topics will be covered
- Reducing license cost by finding and fixing misconfigurations and superfluous accounts
- How do CCB and CCX licenses really work?
- Understanding the DLAU tool and how to best utilize it
- Tips for common problem areas, like team mailboxes, functional/test users, etc
- Practical examples and best practices to implement right away
Fueling AI with Great Data with Airbyte WebinarZilliz
This talk will focus on how to collect data from a variety of sources, leveraging this data for RAG and other GenAI use cases, and finally charting your course to productionalization.
In the realm of cybersecurity, offensive security practices act as a critical shield. By simulating real-world attacks in a controlled environment, these techniques expose vulnerabilities before malicious actors can exploit them. This proactive approach allows manufacturers to identify and fix weaknesses, significantly enhancing system security.
This presentation delves into the development of a system designed to mimic Galileo's Open Service signal using software-defined radio (SDR) technology. We'll begin with a foundational overview of both Global Navigation Satellite Systems (GNSS) and the intricacies of digital signal processing.
The presentation culminates in a live demonstration. We'll showcase the manipulation of Galileo's Open Service pilot signal, simulating an attack on various software and hardware systems. This practical demonstration serves to highlight the potential consequences of unaddressed vulnerabilities, emphasizing the importance of offensive security practices in safeguarding critical infrastructure.
"Choosing proper type of scaling", Olena SyrotaFwdays
Imagine an IoT processing system that is already quite mature and production-ready and for which client coverage is growing and scaling and performance aspects are life and death questions. The system has Redis, MongoDB, and stream processing based on ksqldb. In this talk, firstly, we will analyze scaling approaches and then select the proper ones for our system.
What is an RPA CoE? Session 1 – CoE VisionDianaGray10
In the first session, we will review the organization's vision and how this has an impact on the COE Structure.
Topics covered:
• The role of a steering committee
• How do the organization’s priorities determine CoE Structure?
Speaker:
Chris Bolin, Senior Intelligent Automation Architect Anika Systems
Monitoring and Managing Anomaly Detection on OpenShift.pdfTosin Akinosho
Monitoring and Managing Anomaly Detection on OpenShift
Overview
Dive into the world of anomaly detection on edge devices with our comprehensive hands-on tutorial. This SlideShare presentation will guide you through the entire process, from data collection and model training to edge deployment and real-time monitoring. Perfect for those looking to implement robust anomaly detection systems on resource-constrained IoT/edge devices.
Key Topics Covered
1. Introduction to Anomaly Detection
- Understand the fundamentals of anomaly detection and its importance in identifying unusual behavior or failures in systems.
2. Understanding Edge (IoT)
- Learn about edge computing and IoT, and how they enable real-time data processing and decision-making at the source.
3. What is ArgoCD?
- Discover ArgoCD, a declarative, GitOps continuous delivery tool for Kubernetes, and its role in deploying applications on edge devices.
4. Deployment Using ArgoCD for Edge Devices
- Step-by-step guide on deploying anomaly detection models on edge devices using ArgoCD.
5. Introduction to Apache Kafka and S3
- Explore Apache Kafka for real-time data streaming and Amazon S3 for scalable storage solutions.
6. Viewing Kafka Messages in the Data Lake
- Learn how to view and analyze Kafka messages stored in a data lake for better insights.
7. What is Prometheus?
- Get to know Prometheus, an open-source monitoring and alerting toolkit, and its application in monitoring edge devices.
8. Monitoring Application Metrics with Prometheus
- Detailed instructions on setting up Prometheus to monitor the performance and health of your anomaly detection system.
9. What is Camel K?
- Introduction to Camel K, a lightweight integration framework built on Apache Camel, designed for Kubernetes.
10. Configuring Camel K Integrations for Data Pipelines
- Learn how to configure Camel K for seamless data pipeline integrations in your anomaly detection workflow.
11. What is a Jupyter Notebook?
- Overview of Jupyter Notebooks, an open-source web application for creating and sharing documents with live code, equations, visualizations, and narrative text.
12. Jupyter Notebooks with Code Examples
- Hands-on examples and code snippets in Jupyter Notebooks to help you implement and test anomaly detection models.
Discover top-tier mobile app development services, offering innovative solutions for iOS and Android. Enhance your business with custom, user-friendly mobile applications.
How information systems are built or acquired puts information, which is what they should be about, in a secondary place. Our language adapted accordingly, and we no longer talk about information systems but applications. Applications evolved in a way to break data into diverse fragments, tightly coupled with applications and expensive to integrate. The result is technical debt, which is re-paid by taking even bigger "loans", resulting in an ever-increasing technical debt. Software engineering and procurement practices work in sync with market forces to maintain this trend. This talk demonstrates how natural this situation is. The question is: can something be done to reverse the trend?
Your One-Stop Shop for Python Success: Top 10 US Python Development Providersakankshawande
Simplify your search for a reliable Python development partner! This list presents the top 10 trusted US providers offering comprehensive Python development services, ensuring your project's success from conception to completion.
16. con g.ru
# This file is used by Rack-based
# servers to start the application.
require ::File.expand_path(
'../config/environment',
__FILE__
)
run Tutorial::Application
17. con g/boot.rb
require 'rubygems'
# Set up gems listed in the Gemfile.
gemfile = File.expand_path(
'../../Gemfile',
__FILE__
)
if File.exist?(gemfile)
ENV['BUNDLE_GEMFILE'] = gemfile
require 'bundler'
Bundler.setup
end
19. con g/environment.rb
# Load the rails application
require File.expand_path(
'../application',
__FILE__
)
# Initialize the rails application
Tutorial::Application.initialize!
20. con g/application.rb (1)
require File.expand_path(
'../boot',
__FILE__
)
require 'rails/all'
if defined?(Bundler)
Bundler.require(:default, Rails.env)
end
21. con g/application.rb (2)
module Tutorial
class Application < Rails::Application
config.encoding = "utf-8"
config.filter_parameters +=
[:password]
end
end
22. environments/production.rb
Tutorial::Application.configure do
config.cache_classes = true
config.consider_all_requests_local = false
config.action_controller.perform_caching = true
config.action_dispatch.x_sendfile_header = "X-Sendfile"
config.serve_static_assets = false
end
24. script/rails (1)
#!/usr/bin/env ruby
# This command will automatically
# be run when you run "rails" with
# Rails 3 gems installed from the
# root of your application.
ENV_PATH = File.expand_path(
'../../config/environment',
__FILE__
)
62. Path Scope
match "/admin/posts" => "posts#index"
match "/admin/users" => "users#index"
scope :path => "admin" do
match "/posts" => "posts#index"
match "/users" => "users#index"
end
63. Path Scope
match "/admin/posts" => "posts#index"
match "/admin/users" => "users#index"
scope "admin" do
match "/posts" => "posts#index"
match "/users" => "users#index"
end
65. Module Scope
match "/posts" => "admin/posts#index"
match "/users" => "admin/users#index"
scope :module => "admin" do
match "/posts" => "posts#index"
match "/users" => "users#index"
end
67. Both
match "admin/posts" => "admin/posts#index"
match "admin/users" => "admin/users#index"
namespace "admin" do
match "/posts" => "posts#index"
match "/users" => "users#index"
end
72. Scoping
scope "/posts" do
controller :posts do
get "/" => :index
end
end
get "/posts" => "posts#index"
73. Default Resource Route
controller :posts do
scope "/posts" do
get "/" => :index
post "/" => :create
get "/:id" => :show
put "/:id" => :update
delete "/:id" => :delete
get "/new" => :new
get "/:id/edit" => :edit
end
end
74. Default Resource Route
controller :posts do
scope "/posts" do
get "/" => :index, :as => :posts
post "/" => :create
get "/:id" => :show, :as => :post
put "/:id" => :update
delete "/:id" => :delete
get "/new" => :new, :as => :new_post
get "/:id/edit" => :edit, :as => :edit_post
end
end
107. Rack Endpoint
class MountedEndpoint
def call(env)
head = {"Content-Type" => "text/html"}
body = "script: #{env["SCRIPT_NAME"]}"
body += "path: #{env["PATH_INFO"]}"
[200, head, [body]]
end
end
108. Mounting
class MountedEndpoint
def call(env)
head = {"Content-Type" => "text/html"}
body = "script: #{env["SCRIPT_NAME"]}"
body += "path: #{env["PATH_INFO"]}"
[200, head, [body]]
end
end
mount "/end", :at => MountedEndpoint.new
109. Mounting
class MountedEndpoint
def call(env)
head = {"Content-Type" => "text/html"}
body = "script: #{env["SCRIPT_NAME"]}"
body += "path: #{env["PATH_INFO"]}"
[200, head, [body]]
end
end
mount "/end", :at => MountedEndpoint.new
# "/end/point" =>
# script: /end
# path: /point
113. Chainable Methods
★ select ★ order
★ from ★ limit
★ where ★ offset
★ joins ★ includes
★ having ★ lock
★ group ★ readonly
114. Controller
def index
@posts = Post.
where(:published => true).
order("publish_date desc")
end
115. Model
def index
@posts = Post.published
end
class Post < ActiveRecord::Base
scope :published,
where(:published => true).
order("publish_date desc")
end
116. Model
class Post < ActiveRecord::Base
scope :desc,
order("publish_date desc")
scope :published,
where(:published => true).desc
end
117. Controller
def index
@posts = Post.
where("created_at < ?", Time.now).
order("publish_date desc")
end
118. Controller
def index
@posts = Post.past
end
class Post < ActiveRecord::Base
scope :desc,
order("publish_date desc")
def self.past
where("created_at < ?",
Time.now).desc
end
end
119. Model
class Post < ActiveRecord::Base
scope :desc,
order("publish_date desc")
def self.past
where("created_at < ?",
Time.now).desc
end
def self.recent(number)
past.limit(5)
end
end
120. Pagination
class PostsController < ApplicationController
def index
@posts = Posts.page(5, :per_page => 10)
end
end
class Post < ActiveRecord::Base
def self.page(number, options)
per_page = options[:per_page]
offset(per_page * (number - 1)).
limit(per_page)
end
end
129. Be More Speci c
def welcome(user)
@user = user
mail(:to => user.email,
:subject => "Welcome man!") do |format|
format.html
format.text { render "generic" }
end
end
130. Defaults
default :from => "wycats@gmail.com"
def welcome(user)
@user = user
mail(:to => user.email,
:subject => "Welcome man!") do |format|
format.html
format.text { render "generic" }
end
end
132. Interceptors
class MyInterceptor
def self.delivering_email(mail)
original = mail.to
mail.to = "wycats@gmail.com"
mail.subject =
"#{original}: #{mail.subject}"
end
end
133. Interceptors
class MyInterceptor
def self.delivering_email(mail)
original = mail.to
mail.to = "wycats@gmail.com"
mail.subject =
"#{original}: #{mail.subject}"
end
end
config.action_mailer.
register_interceptor(MyInterceptor)