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.
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.
The document summarizes changes in Rails 3 including:
1. Bundler is introduced for managing gem dependencies through a Gemfile.
2. The ActiveRecord query interface is updated with method chaining and relations to unify finders, named scopes, and with_scope.
3. The ActiveRecord validation API is updated to use hashes instead of separate validator methods for validation options.
4. Views are updated with automatic XSS escaping, unobtrusive JavaScript, and consistent <%= %> usage for output.
5. Internationalization is updated with %{} instead of {{ }} for translations.
A year ago, I was a committed VPS and dedicated-machine deployer. I thought the cloud imposed silly restrictions - how dare you take away my shell account! Whaddya mean I can't save files locally? Since then, I've had some interesting experiences. I've worked on big cloud-deployed systems, and certain large traditionally-deployed systems, and I've seen how a lot of the decisions that you're ... encouraged to make when designing an app to run in the cloud. Most interestingly, I've discovered how those same decisions can make for a much better app regardless of where it'll end up. In this talk, I'll share those architectural patterns with you, and show why they work. Hopefully, I'll convince all of you to build cloud castles -- even if you've got your foundation firmly on the ground.
This document provides an overview of Action Controllers in Ruby on Rails. It discusses controllers acting as a middle layer between models and views, RESTful routing, parameters, sessions, filters, request and response objects, authentication, streaming files, parameter filtering, exception handling, and forcing HTTPS. Key points include controllers conducting an orchestra, handling REST actions, accessing session data, applying filters, and interacting with requests and responses.
This document discusses building REST APIs with Laravel 5. It covers topics like using REST instead of SOAP, authentication with basic authentication and middleware, response formats, controller hierarchy, repositories, data transformers, error handling, and an internal dispatcher for making internal API requests. The goal is to provide best practices and patterns for building robust and well-structured REST APIs with Laravel.
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.
Laravel is a PHP MVC based framework. It is as easy as codeigniter, yet provides powerful tools needed for large robust application.It is built on top of symphony components and is inspired by many other frameworks including RoR, Asp .net, Sinatra.This session focuses on the basics things needed to start building application on it.
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.
The document summarizes changes in Rails 3 including:
1. Bundler is introduced for managing gem dependencies through a Gemfile.
2. The ActiveRecord query interface is updated with method chaining and relations to unify finders, named scopes, and with_scope.
3. The ActiveRecord validation API is updated to use hashes instead of separate validator methods for validation options.
4. Views are updated with automatic XSS escaping, unobtrusive JavaScript, and consistent <%= %> usage for output.
5. Internationalization is updated with %{} instead of {{ }} for translations.
A year ago, I was a committed VPS and dedicated-machine deployer. I thought the cloud imposed silly restrictions - how dare you take away my shell account! Whaddya mean I can't save files locally? Since then, I've had some interesting experiences. I've worked on big cloud-deployed systems, and certain large traditionally-deployed systems, and I've seen how a lot of the decisions that you're ... encouraged to make when designing an app to run in the cloud. Most interestingly, I've discovered how those same decisions can make for a much better app regardless of where it'll end up. In this talk, I'll share those architectural patterns with you, and show why they work. Hopefully, I'll convince all of you to build cloud castles -- even if you've got your foundation firmly on the ground.
This document provides an overview of Action Controllers in Ruby on Rails. It discusses controllers acting as a middle layer between models and views, RESTful routing, parameters, sessions, filters, request and response objects, authentication, streaming files, parameter filtering, exception handling, and forcing HTTPS. Key points include controllers conducting an orchestra, handling REST actions, accessing session data, applying filters, and interacting with requests and responses.
This document discusses building REST APIs with Laravel 5. It covers topics like using REST instead of SOAP, authentication with basic authentication and middleware, response formats, controller hierarchy, repositories, data transformers, error handling, and an internal dispatcher for making internal API requests. The goal is to provide best practices and patterns for building robust and well-structured REST APIs with Laravel.
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.
Laravel is a PHP MVC based framework. It is as easy as codeigniter, yet provides powerful tools needed for large robust application.It is built on top of symphony components and is inspired by many other frameworks including RoR, Asp .net, Sinatra.This session focuses on the basics things needed to start building application on it.
This document discusses Rails form helpers and generating forms in Rails. It covers the form_tag helper which generates form tags, and the form_for helper which binds forms to model objects. It also discusses generating individual form fields like text fields, text areas, checkboxes and radio buttons. Additionally, it covers options for selecting values from a collection and working with nested attributes using fields_for.
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 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.
- The document discusses various rendering methods and layouts in Rails, including default rendering, using the 'render' method, options for render like :content_type and :layout, and using redirect_to versus render. It also covers finding and structuring layouts, asset tag helpers, and head-only responses.
This document provides information about Silex, a PHP micro-framework. It includes usage examples and configuration instructions for Silex on Apache, Nginx, IIS, and Lighttpd web servers. It also covers routing, controllers, middlewares, error handling, and other Silex features.
Slides from a presentation given at Laravel Chicago on November 18, 2014. Goes over the basics of building a REST API using the Laravel framework as well as some handy tips and tools.
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.
OSCON Google App Engine Codelab - July 2010ikailan
Slides for the App Engine codelab given on July 20, 2010. Note that a more verbose version of this codelab is available at:
https://sites.google.com/site/gdevelopercodelabs/app-engine/python-codelab
Keeping the frontend under control with Symfony and WebpackIgnacio Martín
Webpack tutorial with tips for Symfony users. Topics covered include: current frontend trends, setup, loaders, dev tools, optimization in production, bundle splitting and tips and tricks for using webpack with existing projects.
Symfony Munich Meetup 2016.
This document discusses using pluggable applications with TurboGears2. It provides an overview of TurboGears2 features like object dispatch, declarative models, and XML template engines. It then demonstrates how to quickly start an application and explore options to add photo galleries, blogs, and wiki pages by plugging in additional applications and customizing templates and models.
Symfony Guard Authentication: Fun with API Token, Social Login, JWT and moreRyan Weaver
There are so many interesting ways to authenticate a user: via an API token, social login, a traditional HTML form or anything else you can dream up.
But until now, creating a custom authentication system in Symfony has meant a lot of files and a lot of complexity.
Introducing Guard: a simple, but expandable authentication system built on top of Symfony's security component. Want to authenticate via an API token? Great - that's just one class. Social login? Easy! Have some crazy legacy central authentication system? In this talk, we'll show you how you'd implement any of these in your application today.
Don't get me wrong - you'll still need to do some work. But finally, the path will be clear and joyful.
Keeping it Small: Getting to know the Slim Micro FrameworkJeremy Kendall
This document provides an overview of the Slim micro web framework. It discusses that Slim aims for concise and clear code, addresses common use cases well, and is inspired by Sinatra. It provides examples of basic routing and middleware usage in Slim. Key aspects covered include routing, configuration, logging, views, and hooks/middleware.
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.
Introducing Assetic: Asset Management for PHP 5.3Kris Wallsmith
The performance of your application depends heavily on the number and size of assets on each page. Even your blazingly fastest Symfony2 application can be bogged down by bloated Javascript and CSS files. This session will give you a basic introduction to PHP's new asset management framework, Assetic, and explore how it integrates with Symfony2 for a pleasant, common sense developer experience.
This document provides instructions for building a Rails API and discusses related topics. It recommends using Rails 3.1 and Ruby 1.9.2 to build the API. It provides steps to generate a MessagesController to handle API requests for messages. It discusses testing the API with curl and rspec tests. It also covers building a namespaced and versioned API, authentication, caching responses, hosting on DotCloud, and running background jobs with Delayed Job.
This document discusses Flask, a Python-based web application framework. It provides an overview of Flask fundamentals like backend development, virtual environments, routes, templates, and error handling. It also covers additional Flask features like extensions, MongoDB integration, and building REST APIs. The document uses code samples and file structure examples to demonstrate how to structure and deploy a Flask application on Heroku.
Finally, Professional Frontend Dev with ReactJS, WebPack & Symfony (Symfony C...Ryan Weaver
If you're like me, you know that being a great backend developer isn't enough. To make *truly* great applications, we need to spend significant time in an area that's moving at a lightning pace: frontend development.
This talk is for you: the backend developer that wants to hook their API's up to rich, interactive JavaScript frontends. To do that, first, we need to demystify a lot of new terms, like ES6/ES2015, ECMAScript, JSX, Babel and the idea that modern JavaScript (surprise) *requires* a build step.
With this in mind, I'll give you a brief introduction into Webpack & the modular development it finally allows.
But the real star is ReactJS. In the frontend world, you never know what new tech will *win*, but React is a star. I'll give you enough of an intro to get you rolling on your project.
The new frontend dev world is huge! Consider the starting line down an exciting new journey.
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.
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.
This document discusses Rails form helpers and generating forms in Rails. It covers the form_tag helper which generates form tags, and the form_for helper which binds forms to model objects. It also discusses generating individual form fields like text fields, text areas, checkboxes and radio buttons. Additionally, it covers options for selecting values from a collection and working with nested attributes using fields_for.
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 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.
- The document discusses various rendering methods and layouts in Rails, including default rendering, using the 'render' method, options for render like :content_type and :layout, and using redirect_to versus render. It also covers finding and structuring layouts, asset tag helpers, and head-only responses.
This document provides information about Silex, a PHP micro-framework. It includes usage examples and configuration instructions for Silex on Apache, Nginx, IIS, and Lighttpd web servers. It also covers routing, controllers, middlewares, error handling, and other Silex features.
Slides from a presentation given at Laravel Chicago on November 18, 2014. Goes over the basics of building a REST API using the Laravel framework as well as some handy tips and tools.
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.
OSCON Google App Engine Codelab - July 2010ikailan
Slides for the App Engine codelab given on July 20, 2010. Note that a more verbose version of this codelab is available at:
https://sites.google.com/site/gdevelopercodelabs/app-engine/python-codelab
Keeping the frontend under control with Symfony and WebpackIgnacio Martín
Webpack tutorial with tips for Symfony users. Topics covered include: current frontend trends, setup, loaders, dev tools, optimization in production, bundle splitting and tips and tricks for using webpack with existing projects.
Symfony Munich Meetup 2016.
This document discusses using pluggable applications with TurboGears2. It provides an overview of TurboGears2 features like object dispatch, declarative models, and XML template engines. It then demonstrates how to quickly start an application and explore options to add photo galleries, blogs, and wiki pages by plugging in additional applications and customizing templates and models.
Symfony Guard Authentication: Fun with API Token, Social Login, JWT and moreRyan Weaver
There are so many interesting ways to authenticate a user: via an API token, social login, a traditional HTML form or anything else you can dream up.
But until now, creating a custom authentication system in Symfony has meant a lot of files and a lot of complexity.
Introducing Guard: a simple, but expandable authentication system built on top of Symfony's security component. Want to authenticate via an API token? Great - that's just one class. Social login? Easy! Have some crazy legacy central authentication system? In this talk, we'll show you how you'd implement any of these in your application today.
Don't get me wrong - you'll still need to do some work. But finally, the path will be clear and joyful.
Keeping it Small: Getting to know the Slim Micro FrameworkJeremy Kendall
This document provides an overview of the Slim micro web framework. It discusses that Slim aims for concise and clear code, addresses common use cases well, and is inspired by Sinatra. It provides examples of basic routing and middleware usage in Slim. Key aspects covered include routing, configuration, logging, views, and hooks/middleware.
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.
Introducing Assetic: Asset Management for PHP 5.3Kris Wallsmith
The performance of your application depends heavily on the number and size of assets on each page. Even your blazingly fastest Symfony2 application can be bogged down by bloated Javascript and CSS files. This session will give you a basic introduction to PHP's new asset management framework, Assetic, and explore how it integrates with Symfony2 for a pleasant, common sense developer experience.
This document provides instructions for building a Rails API and discusses related topics. It recommends using Rails 3.1 and Ruby 1.9.2 to build the API. It provides steps to generate a MessagesController to handle API requests for messages. It discusses testing the API with curl and rspec tests. It also covers building a namespaced and versioned API, authentication, caching responses, hosting on DotCloud, and running background jobs with Delayed Job.
This document discusses Flask, a Python-based web application framework. It provides an overview of Flask fundamentals like backend development, virtual environments, routes, templates, and error handling. It also covers additional Flask features like extensions, MongoDB integration, and building REST APIs. The document uses code samples and file structure examples to demonstrate how to structure and deploy a Flask application on Heroku.
Finally, Professional Frontend Dev with ReactJS, WebPack & Symfony (Symfony C...Ryan Weaver
If you're like me, you know that being a great backend developer isn't enough. To make *truly* great applications, we need to spend significant time in an area that's moving at a lightning pace: frontend development.
This talk is for you: the backend developer that wants to hook their API's up to rich, interactive JavaScript frontends. To do that, first, we need to demystify a lot of new terms, like ES6/ES2015, ECMAScript, JSX, Babel and the idea that modern JavaScript (surprise) *requires* a build step.
With this in mind, I'll give you a brief introduction into Webpack & the modular development it finally allows.
But the real star is ReactJS. In the frontend world, you never know what new tech will *win*, but React is a star. I'll give you enough of an intro to get you rolling on your project.
The new frontend dev world is huge! Consider the starting line down an exciting new journey.
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.
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.
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.
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.
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.
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.
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.
Session highlighting and demonstrating approaches to common challenges in modern portlet development. Topics include AJAX in JSR-168 and JSR-286 portlets, CSS and Javascript toolkits, security, and optimization of front-end resources. This session was presented at the Jasig Spring 2010 conference in San Diego, CA by Jennifer Bourey.
RSVP Node.js class at www.nycdatascience.com
NYC data science academy's free workshop, given at NYC Open Data Meetup, http://www.meetup.com/NYC-Open-Data/events/163300552/
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
The document discusses Handlebars, a templating language for HTML. It can be used to render dynamic HTML views from JSON data sources by using templates with placeholders that are replaced by values from a context object. An example demonstrates creating a template, compiling it, providing a context with sample data, and rendering the template to insert the dynamic HTML into the page. Handlebars allows separation of design and data for model-view-controller applications.
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.
- Ruby is an interactive, object-oriented programming language created by Yukihiro Matsumoto in 1995.
- Ruby on Rails is a web application framework built on Ruby that emphasizes convention over configuration and is optimized for programmer happiness.
- The document discusses Ruby and Ruby on Rails, providing an overview of their history, key principles like MVC, REST, and conventions used in Rails. It also provides examples of modeling data with classes and ActiveRecord in Rails.
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.
Magento Live Australia 2016: Request FlowVrann Tulika
As a web application, Magento 2’s web request processing flow is similar to all other web framework flows, but offers more extension points to third-party developers. In this session, we will walk through a web request path in the Magento 2 application, from index.php to browser JS application, and will look at extension points available on that path.
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.
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.
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.
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.
"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.
Programming Foundation Models with DSPy - Meetup SlidesZilliz
Prompting language models is hard, while programming language models is easy. In this talk, I will discuss the state-of-the-art framework DSPy for programming foundation models with its powerful optimizers and runtime constraint system.
5th LF Energy Power Grid Model Meet-up SlidesDanBrown980551
5th Power Grid Model Meet-up
It is with great pleasure that we extend to you an invitation to the 5th Power Grid Model Meet-up, scheduled for 6th June 2024. This event will adopt a hybrid format, allowing participants to join us either through an online Mircosoft Teams session or in person at TU/e located at Den Dolech 2, Eindhoven, Netherlands. The meet-up will be hosted by Eindhoven University of Technology (TU/e), a research university specializing in engineering science & technology.
Power Grid Model
The global energy transition is placing new and unprecedented demands on Distribution System Operators (DSOs). Alongside upgrades to grid capacity, processes such as digitization, capacity optimization, and congestion management are becoming vital for delivering reliable services.
Power Grid Model is an open source project from Linux Foundation Energy and provides a calculation engine that is increasingly essential for DSOs. It offers a standards-based foundation enabling real-time power systems analysis, simulations of electrical power grids, and sophisticated what-if analysis. In addition, it enables in-depth studies and analysis of the electrical power grid’s behavior and performance. This comprehensive model incorporates essential factors such as power generation capacity, electrical losses, voltage levels, power flows, and system stability.
Power Grid Model is currently being applied in a wide variety of use cases, including grid planning, expansion, reliability, and congestion studies. It can also help in analyzing the impact of renewable energy integration, assessing the effects of disturbances or faults, and developing strategies for grid control and optimization.
What to expect
For the upcoming meetup we are organizing, we have an exciting lineup of activities planned:
-Insightful presentations covering two practical applications of the Power Grid Model.
-An update on the latest advancements in Power Grid -Model technology during the first and second quarters of 2024.
-An interactive brainstorming session to discuss and propose new feature requests.
-An opportunity to connect with fellow Power Grid Model enthusiasts and users.
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.
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.
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
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.
"Frontline Battles with DDoS: Best practices and Lessons Learned", Igor IvaniukFwdays
At this talk we will discuss DDoS protection tools and best practices, discuss network architectures and what AWS has to offer. Also, we will look into one of the largest DDoS attacks on Ukrainian infrastructure that happened in February 2022. We'll see, what techniques helped to keep the web resources available for Ukrainians and how AWS improved DDoS protection for all customers based on Ukraine experience
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?
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.
Driving Business Innovation: Latest Generative AI Advancements & Success StorySafe Software
Are you ready to revolutionize how you handle data? Join us for a webinar where we’ll bring you up to speed with the latest advancements in Generative AI technology and discover how leveraging FME with tools from giants like Google Gemini, Amazon, and Microsoft OpenAI can supercharge your workflow efficiency.
During the hour, we’ll take you through:
Guest Speaker Segment with Hannah Barrington: Dive into the world of dynamic real estate marketing with Hannah, the Marketing Manager at Workspace Group. Hear firsthand how their team generates engaging descriptions for thousands of office units by integrating diverse data sources—from PDF floorplans to web pages—using FME transformers, like OpenAIVisionConnector and AnthropicVisionConnector. This use case will show you how GenAI can streamline content creation for marketing across the board.
Ollama Use Case: Learn how Scenario Specialist Dmitri Bagh has utilized Ollama within FME to input data, create custom models, and enhance security protocols. This segment will include demos to illustrate the full capabilities of FME in AI-driven processes.
Custom AI Models: Discover how to leverage FME to build personalized AI models using your data. Whether it’s populating a model with local data for added security or integrating public AI tools, find out how FME facilitates a versatile and secure approach to AI.
We’ll wrap up with a live Q&A session where you can engage with our experts on your specific use cases, and learn more about optimizing your data workflows with AI.
This webinar is ideal for professionals seeking to harness the power of AI within their data management systems while ensuring high levels of customization and security. Whether you're a novice or an expert, gain actionable insights and strategies to elevate your data processes. Join us to see how FME and AI can revolutionize how you work with data!
Essentials of Automations: Exploring Attributes & Automation ParametersSafe Software
Building automations in FME Flow can save time, money, and help businesses scale by eliminating data silos and providing data to stakeholders in real-time. One essential component to orchestrating complex automations is the use of attributes & automation parameters (both formerly known as “keys”). In fact, it’s unlikely you’ll ever build an Automation without using these components, but what exactly are they?
Attributes & automation parameters enable the automation author to pass data values from one automation component to the next. During this webinar, our FME Flow Specialists will cover leveraging the three types of these output attributes & parameters in FME Flow: Event, Custom, and Automation. As a bonus, they’ll also be making use of the Split-Merge Block functionality.
You’ll leave this webinar with a better understanding of how to maximize the potential of automations by making use of attributes & automation parameters, with the ultimate goal of setting your enterprise integration workflows up on autopilot.
[OReilly Superstream] Occupy the Space: A grassroots guide to engineering (an...Jason Yip
The typical problem in product engineering is not bad strategy, so much as “no strategy”. This leads to confusion, lack of motivation, and incoherent action. The next time you look for a strategy and find an empty space, instead of waiting for it to be filled, I will show you how to fill it in yourself. If you’re wrong, it forces a correction. If you’re right, it helps create focus. I’ll share how I’ve approached this in the past, both what works and lessons for what didn’t work so well.
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__
)
67. 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
68. 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
103. Controller
def index
@posts = Post.
where("created_at < ?", Time.now).
order("publish_date desc")
end
104. Model
scope :desc,
order("publish_date desc")
def self.past
where("created_at < ?",
Time.now).desc
end
105. Model
scope :desc,
order("publish_date desc")
def self.past
where("created_at < ?",
Time.now).desc
end
def self.recent(number)
past.limit(5)
end
106. Pagination
class PostsController
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
115. 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
116. 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
118. Interceptors
class MyInterceptor
def self.delivering_email(mail)
original = mail.to
mail.to = "wycats@gmail.com"
mail.subject =
"#{original}: #{mail.subject}"
end
end
119. 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)