This document discusses Ruby APIs for NoSQL databases. It begins by describing the traditional Rails baseline of using a SQL database like MySQL or PostgreSQL. It then shows how NoSQL databases like MongoDB, Redis, Solr and S3 have been integrated with Rails using adapter gems. The document questions how to unify a data model across multiple data stores and replace the primary store. It explains these challenges have not been fully solved yet but Rails 3 provides a way to replace the primary store by allowing models to work with different adapters.
- Ember.js is a JavaScript MVC framework that aims to make developing ambitious web applications easier. It provides conventions like naming that generate necessary code behind the scenes.
- Ember uses bindings to keep objects and templates in sync as data changes. Computed properties and templates automatically update.
- Ember provides an alternative to just using jQuery for interactive sites, handling changes to HTML to keep functionality working as the codebase grows in complexity.
This document provides an introduction to creating Search Monkeys for Yahoo! Search. Search Monkeys allow developers to enhance search results with additional information. The document demonstrates how to create basic monkeys using microformats or XSLT to extract data from pages. It shows an example of a monkey displaying a Facebook profile photo in results and another displaying photos and descriptions from Flickr pages. The document encourages exploring more advanced features like handling different page types and using infobars.
Reducing Pager Fatigue Using a Serverless ML BotMike Fowler
Being woken up at 3 am by the pager is never fun but seeing an incident resolve before you’ve even left the bed is maddening. Sleepily the next day you tune the alert for a better night’s sleep yet more untuned alerts sing to you in your sleep. After a few rounds of alert-tuning whack-a-mole you wonder: Could I predict if an incident will resolve itself?
This is the story of how a weary engineer used a Cloud ML model with Cloud Functions to reduce pager noise. Recounting some of the challenges faced, we’ll explore training a model with a limited data set & continual training in a serverless environment. We’ll also explore the implications of using a bot as a first responder to a pager.
The document discusses teaching Ruby programming to kids. It argues that teaching programming is important because programming literacy is increasing and it is rewarding to share your excitement about programming with others. It recommends using an agile approach to teaching, with short iterations, listening to student feedback, and adapting lessons. The goals should be specific, measurable, and achievable, like getting students interested or excited about programming. Tools like Shoes, Hackety Hack and Ruby can be used to keep lessons interactive and visual. Practice is important, as is following student interests and looking for teachable moments.
The document discusses how to namedrop various JavaScript MVC frameworks like Backbone.js, Ember.js, and Angular.js to sound knowledgeable in casual conversations. It lists the major frameworks and some of their key features and tradeoffs. The document is intended to help readers learn about these frameworks at a high level so they can casually discuss them without coming across as ignorant.
Moving the Needle: How SF Ruby Got to 18%Sarah Mei
The document discusses efforts to increase female participation in the SF Ruby Meetup group from 2% to 18% between January 2009 and January 2010. It describes implementing an "XTREME COMMUNITY" approach with three parts: 1) Set specific goals focused on issues that can be addressed, 2) Host targeted events and tie them to goals, 3) Cultivate new participants through outreach, visibility, and follow up. The approach resulted in not only more female attendees but an more active community overall with varied talks and newbie-friendly events. Sustaining progress remains difficult due to entrenched social issues and need for leadership commitment.
The document provides an overview of the speaker's approach to writing JavaScript for web applications. It discusses some of the shortcomings of Rails' approach of generating JavaScript (RJS) and embedding it directly in views. The speaker advocates for treating JavaScript as a first-class language by: writing it in standalone files organized into classes; structuring classes based on behavior and page location; and test-driving JavaScript code using the Jasmine framework. This allows JavaScript to be developed and tested independently using an object-oriented approach.
- Ember.js is a JavaScript MVC framework that aims to make developing ambitious web applications easier. It provides conventions like naming that generate necessary code behind the scenes.
- Ember uses bindings to keep objects and templates in sync as data changes. Computed properties and templates automatically update.
- Ember provides an alternative to just using jQuery for interactive sites, handling changes to HTML to keep functionality working as the codebase grows in complexity.
This document provides an introduction to creating Search Monkeys for Yahoo! Search. Search Monkeys allow developers to enhance search results with additional information. The document demonstrates how to create basic monkeys using microformats or XSLT to extract data from pages. It shows an example of a monkey displaying a Facebook profile photo in results and another displaying photos and descriptions from Flickr pages. The document encourages exploring more advanced features like handling different page types and using infobars.
Reducing Pager Fatigue Using a Serverless ML BotMike Fowler
Being woken up at 3 am by the pager is never fun but seeing an incident resolve before you’ve even left the bed is maddening. Sleepily the next day you tune the alert for a better night’s sleep yet more untuned alerts sing to you in your sleep. After a few rounds of alert-tuning whack-a-mole you wonder: Could I predict if an incident will resolve itself?
This is the story of how a weary engineer used a Cloud ML model with Cloud Functions to reduce pager noise. Recounting some of the challenges faced, we’ll explore training a model with a limited data set & continual training in a serverless environment. We’ll also explore the implications of using a bot as a first responder to a pager.
The document discusses teaching Ruby programming to kids. It argues that teaching programming is important because programming literacy is increasing and it is rewarding to share your excitement about programming with others. It recommends using an agile approach to teaching, with short iterations, listening to student feedback, and adapting lessons. The goals should be specific, measurable, and achievable, like getting students interested or excited about programming. Tools like Shoes, Hackety Hack and Ruby can be used to keep lessons interactive and visual. Practice is important, as is following student interests and looking for teachable moments.
The document discusses how to namedrop various JavaScript MVC frameworks like Backbone.js, Ember.js, and Angular.js to sound knowledgeable in casual conversations. It lists the major frameworks and some of their key features and tradeoffs. The document is intended to help readers learn about these frameworks at a high level so they can casually discuss them without coming across as ignorant.
Moving the Needle: How SF Ruby Got to 18%Sarah Mei
The document discusses efforts to increase female participation in the SF Ruby Meetup group from 2% to 18% between January 2009 and January 2010. It describes implementing an "XTREME COMMUNITY" approach with three parts: 1) Set specific goals focused on issues that can be addressed, 2) Host targeted events and tie them to goals, 3) Cultivate new participants through outreach, visibility, and follow up. The approach resulted in not only more female attendees but an more active community overall with varied talks and newbie-friendly events. Sustaining progress remains difficult due to entrenched social issues and need for leadership commitment.
The document provides an overview of the speaker's approach to writing JavaScript for web applications. It discusses some of the shortcomings of Rails' approach of generating JavaScript (RJS) and embedding it directly in views. The speaker advocates for treating JavaScript as a first-class language by: writing it in standalone files organized into classes; structuring classes based on behavior and page location; and test-driving JavaScript code using the Jasmine framework. This allows JavaScript to be developed and tested independently using an object-oriented approach.
The document discusses improving ActiveRecord in Rails 3. It notes that ActiveRecord feels outdated and expresses a desire for newer database modeling techniques. It then summarizes some of the key improvements to ActiveRecord in Rails 3, including ActiveRelation which uses Arel for relational algebra under the hood. This makes database operations like finder methods chainable and lazy loaded. It also discusses improving how scopes can be reused, merged, and applied. The document recommends these features make ActiveRecord simpler to use and more flexible for modeling data.
Rackspace monitors tens of thousands of servers using several open source tools like Apache Cassandra, Zookeeper, and Scribe. They developed their own tools like Virgo and Dreadnot to deploy agents and configure clusters across datacenters. Regular testing, deployment automation with Dreadnot and Chef, and documentation help support the large-scale monitoring system.
Are Today’s Good Practices… Tomorrow’s Performance Anti-Patterns?Andy Davies
This document discusses how performance best practices may become anti-patterns as technologies evolve. It explores how techniques like data URIs, domain sharding, and CSS sprites could be negatively impacted by new protocols like SPDY. The author advocates experimenting with modern tools like mod_pagespeed to test different optimizations under various conditions and sharing results. Continued improvement of debugging tools is also important to help evaluate new approaches as the network landscape changes. Overall, the message is that situational optimization will become more important over rigid rules as complexity increases.
Mobious(ES6 Isomorphic Flux/ReactJS Boilerplate)Ch Rick
This document discusses Mobious, an ES6 isomorphic Flux/ReactJS framework. It includes sections on the front-end using ReactJS and alt, the back-end using Koa, Sequelize and Mocha, performance and isomorphic capabilities, and an example application with friends data. Setup instructions are provided to clone the Mobious repo and install dependencies to start developing with the step-by-step approach outlined.
From Zero to Performance Hero in Minutes - Agile Testing Days 2014 PotsdamAndreas Grabner
As a Tester you need to level up. You can do more than functional verification or reporting Response Time
In my Performance Clinic Workshops I show you real life exampls on why Applications fail and what you can do to find these problems when you are testing these applications.
I am using Free Tools for all of these excercises - especially Dynatrace which gives full End-to-End Visibility (Browser to Database). You can test and download Dynatrace for Free @ http://bit.ly/atd2014challenge
JRuby, Ruby, Rails and You on the Cloud is a presentation about using Ruby on Rails with JRuby on cloud platforms. It introduces JRuby and how to set up a development environment. It demonstrates generating a Rails scaffold and accessing Java libraries from Rails. Deployment options on platforms like Engine Yard AppCloud are discussed. The presentation provides an overview of testing and recommends resources for learning more about Ruby, Rails, JRuby and deployment strategies.
Experience feedback on 10 monthes of happy mongodb usage at fotopedia.
You may also checkout: http://www.slideshare.net/octplane/mongodb-vs-mysql-a-devops-point-of-view
How to use NoSQL in Enterprise Java Applications - NoSQL Roadshow ZurichPatrick Baumgartner
This document discusses how to use NoSQL databases in enterprise Java applications. It provides an overview of Spring Data, an open source framework that supports NoSQL and SQL databases. Spring Data provides common infrastructure and repositories to access data stores like MongoDB, Redis, and Neo4J. The presentation includes an example of using Spring Data to access MongoDB, with annotations for entities, configuration for the data store, and repositories for data access. Attendees are encouraged to try Spring Data with a data model that matches their data.
The document discusses optimizing frontend performance. It recommends reducing HTTP requests by combining CSS files into one file and using sprites and data URIs for images. It also suggests automating minification, compression, and image optimization. Performance should be monitored using tools like WebPagetest, YSlow, and PageSpeed. Frontend optimizations like these can reduce page load times and bandwidth usage.
As browsers explode with new capabilities and migrate onto devices users can be left wondering, “what’s taking so long?” Learn how HTML, CSS, JavaScript, and the web itself conspire against a fast-running application and simple tips to create a snappy interface that delight users instead of frustrating them.
Simplifying building & getting started with universal, single page applications (React/React-Router/Redux ecosystem).
https://github.com/raisemarketplace/ground-control
https://github.com/ndreckshage/sambell
The document provides an overview of CycleJS and reactive programming (RP). It discusses why the author chose CycleJS and RP due to their component model, declarative code, and explicit data flow. It addresses some initial concerns with RP like requiring a "brain rewire" and barriers to reuse. It demonstrates a simple app called Brian designed for people with cognitive disabilities. It describes the learning process of getting used to RP concepts like state management and higher order operators. Resources for learning more about CycleJS, RxJS, and debugging reactive apps are provided. The author notes improvements from the XStream library and looks forward to better visualization and debugging tools.
Ruby and Twitter at the Ruby drink-up of Sophia, January 2013rivierarb
The document summarizes Twitter's history with Ruby on Rails. It began using Rails to quickly prototype and launch the initial site. However, scaling issues emerged as Twitter grew rapidly. By 2009, performance problems led Twitter to abandon Rails for the backend and instead use technologies like Scala, Java, and Lucene. While Ruby was kept for the frontend, Twitter replaced even the Rails frontend in 2011. Scaling demands required moving away from Rails as the site expanded to hundreds of millions of users.
A walkthrough of various application performance tuning tools and a good workflow for where to start, from a presentation at WindyCityRails 2011 in Chicago, IL.
See the video, and more Web and Ruby/Rails Performance info at www.RailsPerformance.com
-John McCaffrey
5 best practices for (web/ software) development (2010)Erwin Elling
Some of the best practices we've acquired while developing for the web! A presentation for students Communication and Multimedia Design at Noordelijke Hogeschool Leeuwarden in their Discover Web2.0 lecture series.
This document discusses integrating RDF and semantic web technologies with the Drupal content management system. It provides an overview of Drupal, describes how its data model of content types and fields can be mapped to RDF classes and properties, and details an experiment exposing Drupal data in RDF format. It notes that Drupal 7 will natively support RDFa and help expose more linked data on the web through its large user base of over 227,000 sites.
This document provides an introduction and overview of big data technologies. It begins with an outline that covers introductions to big data, NoSQL databases, MapReduce and Hadoop, and Hive, HBase and Sqoop. It then discusses relational databases and SQL before introducing NoSQL databases. Key reasons for using NoSQL databases are explained, including improved scalability, lower costs, flexibility in data structures, and high availability. Examples of big data applications and the internet of things are also presented.
Apache Solr is an open-source enterprise search platform built on Apache Lucene. It started as an in-house project at CNET for adding search functionality to their website and was donated to the Apache Software Foundation in 2006. Key features of Solr include faceted search, filtering, hit highlighting, dynamic clustering, database integration, and replication to support scalability.
Cloud Data Warehousing presentation by Rogier Werschkull, including tips, bes...Patrick Van Renterghem
Presentation on "Cloud Data Warehousing: What, Why and How?" by Rogier Werschkull (RogerData), at the BI & Data Analytics Summit on June 13th, 2019 in Diegem (Belgium)
This document outlines 10 web performance lessons for the 21st century. The lessons are: 1) Measure first, optimize bottlenecks second 2) Measure what matters 3) Get a performance budget 4) Write JavaScript efficiently using mostly functions 5) Write code efficiently using mostly HTML 6) Consider static functional programming as JavaScript may not be enough 7) Observe how browsers work behind the scenes 8) Build fast organizations 9) Have courage in your minimalism 10) Sometimes keeping it simple with 9 lessons is enough. The document provides explanations and examples for each lesson along with relevant links to additional resources.
"What does it really mean for your system to be available, or how to define w...Fwdays
We will talk about system monitoring from a few different angles. We will start by covering the basics, then discuss SLOs, how to define them, and why understanding the business well is crucial for success in this exercise.
High performance Serverless Java on AWS- GoTo Amsterdam 2024Vadym Kazulkin
Java is for many years one of the most popular programming languages, but it used to have hard times in the Serverless community. Java is known for its high cold start times and high memory footprint, comparing to other programming languages like Node.js and Python. In this talk I'll look at the general best practices and techniques we can use to decrease memory consumption, cold start times for Java Serverless development on AWS including GraalVM (Native Image) and AWS own offering SnapStart based on Firecracker microVM snapshot and restore and CRaC (Coordinated Restore at Checkpoint) runtime hooks. I'll also provide a lot of benchmarking on Lambda functions trying out various deployment package sizes, Lambda memory settings, Java compilation options and HTTP (a)synchronous clients and measure their impact on cold and warm start times.
More Related Content
Similar to Ruby APIs for NoSQL - Polyglot Persistence - GoGaRuCo 2010
The document discusses improving ActiveRecord in Rails 3. It notes that ActiveRecord feels outdated and expresses a desire for newer database modeling techniques. It then summarizes some of the key improvements to ActiveRecord in Rails 3, including ActiveRelation which uses Arel for relational algebra under the hood. This makes database operations like finder methods chainable and lazy loaded. It also discusses improving how scopes can be reused, merged, and applied. The document recommends these features make ActiveRecord simpler to use and more flexible for modeling data.
Rackspace monitors tens of thousands of servers using several open source tools like Apache Cassandra, Zookeeper, and Scribe. They developed their own tools like Virgo and Dreadnot to deploy agents and configure clusters across datacenters. Regular testing, deployment automation with Dreadnot and Chef, and documentation help support the large-scale monitoring system.
Are Today’s Good Practices… Tomorrow’s Performance Anti-Patterns?Andy Davies
This document discusses how performance best practices may become anti-patterns as technologies evolve. It explores how techniques like data URIs, domain sharding, and CSS sprites could be negatively impacted by new protocols like SPDY. The author advocates experimenting with modern tools like mod_pagespeed to test different optimizations under various conditions and sharing results. Continued improvement of debugging tools is also important to help evaluate new approaches as the network landscape changes. Overall, the message is that situational optimization will become more important over rigid rules as complexity increases.
Mobious(ES6 Isomorphic Flux/ReactJS Boilerplate)Ch Rick
This document discusses Mobious, an ES6 isomorphic Flux/ReactJS framework. It includes sections on the front-end using ReactJS and alt, the back-end using Koa, Sequelize and Mocha, performance and isomorphic capabilities, and an example application with friends data. Setup instructions are provided to clone the Mobious repo and install dependencies to start developing with the step-by-step approach outlined.
From Zero to Performance Hero in Minutes - Agile Testing Days 2014 PotsdamAndreas Grabner
As a Tester you need to level up. You can do more than functional verification or reporting Response Time
In my Performance Clinic Workshops I show you real life exampls on why Applications fail and what you can do to find these problems when you are testing these applications.
I am using Free Tools for all of these excercises - especially Dynatrace which gives full End-to-End Visibility (Browser to Database). You can test and download Dynatrace for Free @ http://bit.ly/atd2014challenge
JRuby, Ruby, Rails and You on the Cloud is a presentation about using Ruby on Rails with JRuby on cloud platforms. It introduces JRuby and how to set up a development environment. It demonstrates generating a Rails scaffold and accessing Java libraries from Rails. Deployment options on platforms like Engine Yard AppCloud are discussed. The presentation provides an overview of testing and recommends resources for learning more about Ruby, Rails, JRuby and deployment strategies.
Experience feedback on 10 monthes of happy mongodb usage at fotopedia.
You may also checkout: http://www.slideshare.net/octplane/mongodb-vs-mysql-a-devops-point-of-view
How to use NoSQL in Enterprise Java Applications - NoSQL Roadshow ZurichPatrick Baumgartner
This document discusses how to use NoSQL databases in enterprise Java applications. It provides an overview of Spring Data, an open source framework that supports NoSQL and SQL databases. Spring Data provides common infrastructure and repositories to access data stores like MongoDB, Redis, and Neo4J. The presentation includes an example of using Spring Data to access MongoDB, with annotations for entities, configuration for the data store, and repositories for data access. Attendees are encouraged to try Spring Data with a data model that matches their data.
The document discusses optimizing frontend performance. It recommends reducing HTTP requests by combining CSS files into one file and using sprites and data URIs for images. It also suggests automating minification, compression, and image optimization. Performance should be monitored using tools like WebPagetest, YSlow, and PageSpeed. Frontend optimizations like these can reduce page load times and bandwidth usage.
As browsers explode with new capabilities and migrate onto devices users can be left wondering, “what’s taking so long?” Learn how HTML, CSS, JavaScript, and the web itself conspire against a fast-running application and simple tips to create a snappy interface that delight users instead of frustrating them.
Simplifying building & getting started with universal, single page applications (React/React-Router/Redux ecosystem).
https://github.com/raisemarketplace/ground-control
https://github.com/ndreckshage/sambell
The document provides an overview of CycleJS and reactive programming (RP). It discusses why the author chose CycleJS and RP due to their component model, declarative code, and explicit data flow. It addresses some initial concerns with RP like requiring a "brain rewire" and barriers to reuse. It demonstrates a simple app called Brian designed for people with cognitive disabilities. It describes the learning process of getting used to RP concepts like state management and higher order operators. Resources for learning more about CycleJS, RxJS, and debugging reactive apps are provided. The author notes improvements from the XStream library and looks forward to better visualization and debugging tools.
Ruby and Twitter at the Ruby drink-up of Sophia, January 2013rivierarb
The document summarizes Twitter's history with Ruby on Rails. It began using Rails to quickly prototype and launch the initial site. However, scaling issues emerged as Twitter grew rapidly. By 2009, performance problems led Twitter to abandon Rails for the backend and instead use technologies like Scala, Java, and Lucene. While Ruby was kept for the frontend, Twitter replaced even the Rails frontend in 2011. Scaling demands required moving away from Rails as the site expanded to hundreds of millions of users.
A walkthrough of various application performance tuning tools and a good workflow for where to start, from a presentation at WindyCityRails 2011 in Chicago, IL.
See the video, and more Web and Ruby/Rails Performance info at www.RailsPerformance.com
-John McCaffrey
5 best practices for (web/ software) development (2010)Erwin Elling
Some of the best practices we've acquired while developing for the web! A presentation for students Communication and Multimedia Design at Noordelijke Hogeschool Leeuwarden in their Discover Web2.0 lecture series.
This document discusses integrating RDF and semantic web technologies with the Drupal content management system. It provides an overview of Drupal, describes how its data model of content types and fields can be mapped to RDF classes and properties, and details an experiment exposing Drupal data in RDF format. It notes that Drupal 7 will natively support RDFa and help expose more linked data on the web through its large user base of over 227,000 sites.
This document provides an introduction and overview of big data technologies. It begins with an outline that covers introductions to big data, NoSQL databases, MapReduce and Hadoop, and Hive, HBase and Sqoop. It then discusses relational databases and SQL before introducing NoSQL databases. Key reasons for using NoSQL databases are explained, including improved scalability, lower costs, flexibility in data structures, and high availability. Examples of big data applications and the internet of things are also presented.
Apache Solr is an open-source enterprise search platform built on Apache Lucene. It started as an in-house project at CNET for adding search functionality to their website and was donated to the Apache Software Foundation in 2006. Key features of Solr include faceted search, filtering, hit highlighting, dynamic clustering, database integration, and replication to support scalability.
Cloud Data Warehousing presentation by Rogier Werschkull, including tips, bes...Patrick Van Renterghem
Presentation on "Cloud Data Warehousing: What, Why and How?" by Rogier Werschkull (RogerData), at the BI & Data Analytics Summit on June 13th, 2019 in Diegem (Belgium)
This document outlines 10 web performance lessons for the 21st century. The lessons are: 1) Measure first, optimize bottlenecks second 2) Measure what matters 3) Get a performance budget 4) Write JavaScript efficiently using mostly functions 5) Write code efficiently using mostly HTML 6) Consider static functional programming as JavaScript may not be enough 7) Observe how browsers work behind the scenes 8) Build fast organizations 9) Have courage in your minimalism 10) Sometimes keeping it simple with 9 lessons is enough. The document provides explanations and examples for each lesson along with relevant links to additional resources.
Similar to Ruby APIs for NoSQL - Polyglot Persistence - GoGaRuCo 2010 (20)
"What does it really mean for your system to be available, or how to define w...Fwdays
We will talk about system monitoring from a few different angles. We will start by covering the basics, then discuss SLOs, how to define them, and why understanding the business well is crucial for success in this exercise.
High performance Serverless Java on AWS- GoTo Amsterdam 2024Vadym Kazulkin
Java is for many years one of the most popular programming languages, but it used to have hard times in the Serverless community. Java is known for its high cold start times and high memory footprint, comparing to other programming languages like Node.js and Python. In this talk I'll look at the general best practices and techniques we can use to decrease memory consumption, cold start times for Java Serverless development on AWS including GraalVM (Native Image) and AWS own offering SnapStart based on Firecracker microVM snapshot and restore and CRaC (Coordinated Restore at Checkpoint) runtime hooks. I'll also provide a lot of benchmarking on Lambda functions trying out various deployment package sizes, Lambda memory settings, Java compilation options and HTTP (a)synchronous clients and measure their impact on cold and warm start times.
[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.
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
Discover top-tier mobile app development services, offering innovative solutions for iOS and Android. Enhance your business with custom, user-friendly mobile applications.
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
QA or the Highway - Component Testing: Bridging the gap between frontend appl...zjhamm304
These are the slides for the presentation, "Component Testing: Bridging the gap between frontend applications" that was presented at QA or the Highway 2024 in Columbus, OH by Zachary Hamm.
This talk will cover ScyllaDB Architecture from the cluster-level view and zoom in on data distribution and internal node architecture. In the process, we will learn the secret sauce used to get ScyllaDB's high availability and superior performance. We will also touch on the upcoming changes to ScyllaDB architecture, moving to strongly consistent metadata and tablets.
The Department of Veteran Affairs (VA) invited Taylor Paschal, Knowledge & Information Management Consultant at Enterprise Knowledge, to speak at a Knowledge Management Lunch and Learn hosted on June 12, 2024. All Office of Administration staff were invited to attend and received professional development credit for participating in the voluntary event.
The objectives of the Lunch and Learn presentation were to:
- Review what KM ‘is’ and ‘isn’t’
- Understand the value of KM and the benefits of engaging
- Define and reflect on your “what’s in it for me?”
- Share actionable ways you can participate in Knowledge - - Capture & Transfer
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?
The Microsoft 365 Migration Tutorial For Beginner.pptxoperationspcvita
This presentation will help you understand the power of Microsoft 365. However, we have mentioned every productivity app included in Office 365. Additionally, we have suggested the migration situation related to Office 365 and how we can help you.
You can also read: https://www.systoolsgroup.com/updates/office-365-tenant-to-tenant-migration-step-by-step-complete-guide/
zkStudyClub - LatticeFold: A Lattice-based Folding Scheme and its Application...Alex Pruden
Folding is a recent technique for building efficient recursive SNARKs. Several elegant folding protocols have been proposed, such as Nova, Supernova, Hypernova, Protostar, and others. However, all of them rely on an additively homomorphic commitment scheme based on discrete log, and are therefore not post-quantum secure. In this work we present LatticeFold, the first lattice-based folding protocol based on the Module SIS problem. This folding protocol naturally leads to an efficient recursive lattice-based SNARK and an efficient PCD scheme. LatticeFold supports folding low-degree relations, such as R1CS, as well as high-degree relations, such as CCS. The key challenge is to construct a secure folding protocol that works with the Ajtai commitment scheme. The difficulty, is ensuring that extracted witnesses are low norm through many rounds of folding. We present a novel technique using the sumcheck protocol to ensure that extracted witnesses are always low norm no matter how many rounds of folding are used. Our evaluation of the final proof system suggests that it is as performant as Hypernova, while providing post-quantum security.
Paper Link: https://eprint.iacr.org/2024/257
In our second session, we shall learn all about the main features and fundamentals of UiPath Studio that enable us to use the building blocks for any automation project.
📕 Detailed agenda:
Variables and Datatypes
Workflow Layouts
Arguments
Control Flows and Loops
Conditional Statements
💻 Extra training through UiPath Academy:
Variables, Constants, and Arguments in Studio
Control Flow in Studio
inQuba Webinar Mastering Customer Journey Management with Dr Graham HillLizaNolte
HERE IS YOUR WEBINAR CONTENT! 'Mastering Customer Journey Management with Dr. Graham Hill'. We hope you find the webinar recording both insightful and enjoyable.
In this webinar, we explored essential aspects of Customer Journey Management and personalization. Here’s a summary of the key insights and topics discussed:
Key Takeaways:
Understanding the Customer Journey: Dr. Hill emphasized the importance of mapping and understanding the complete customer journey to identify touchpoints and opportunities for improvement.
Personalization Strategies: We discussed how to leverage data and insights to create personalized experiences that resonate with customers.
Technology Integration: Insights were shared on how inQuba’s advanced technology can streamline customer interactions and drive operational efficiency.
"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
"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.
38. 2 Questions
• How do you unify a model with data
scattered across multiple stores?
• How do you replace the primary store?
39. 2 Questions
not solved yet
• How do you unify a model with data
scattered across multiple stores?
• How do you replace the primary store?
40. 2 Questions
not solved yet
• How do you unify a model with data
scattered across multiple stores?
• solved inyou replace the primary store?
How do
Rails 3
I’m Sarah Mei, and I’m a Ruby developer at Pivotal Labs here in San Francisco. We’re an agile consulting company, and we do a lot of Rails. I’m here to talk to you today about Ruby APIs for NoSQL. I also like to call this talk....
Polyglot Persistence. We’re going to talk about how you store data in Ruby when you’re writing a system that uses more than just a relational database. And I’d like to start with a little bit of audience participation... so get ready....
Show of hands: who’s written an application in Ruby that uses a relational database to store data?
Who’s written a Ruby app that uses a relational database AND some kind of alternative datastore?
Who’s written a Ruby app that uses ONLY non-relational datastores?
So I’m going to start off by showing you this diagram that’s been in hundreds of “teach yourself Rails in 25 seconds” type blog posts. Here we have a vanilla Rails application - requests come in, they go through routes to a controller, which cedes to the models, which use ActiveRecord to access MySQL. And then we go back the way we came, except on the way out we go through views instead of routes, and return a response.
I was showing this diagram to a friend, and he said, “you know, if you have a diagram like this, you are legally required to have a little drawing of a cloud to represent the internet.” So...
There you go. Anyway, I would be surprised if anyone in this room has written a real application with real users in which these are the only boxes that appear on the system diagram, and in particular, in which MySQL is the only way data is persisted. Certainly you don’t set out to create a poly-persistant system - it just happens. It starts innocently enough ...
You add solr for free-text search. Pretty soon though you have more than one app server, so you start...
...uploading your assets to s3. Pretty soon you realize you need to do some...
...background jobs, so you install a little resque in there. Then since you’re a social network you realize you need to cache your friend lists, so you toss those in redis too...
And pretty soon you decide you need an object cache, so you stick in cache-money...and let me just pause to say that I’m drawing all these arrows into and out of the models. That’s what you should do. I know some of you put this logic in your controllers, but I’m ignoring you. Let’s pretend we put it all in the right place.
So, at this point, you have five different datastores, and you haven’t even done anything particularly crazy. In fact I would say that this type of setup is a lot more common in real applications than my original undecorated diagram of what a Rails app looks like. This is really what a basic Rails app looks like these days.
It’s the new normal. It’s pretty amazing! In the last year, we’ve come to recognize that most applications have models with data that doesn’t fit relational persistence very well.
These models have relationships, which are hard to model in SQL - those joins get nasty pretty quick. They have blocks of text that need to be searched semantically. They have frequently-read, rarely-written objects that need to be retrieved very very quickly. And they have associated assets that go along with them.
And I would like to point out, before I go on, that until recently, we didn’t even think of all of these things as alternative datastores. Cassandra and redis, certainly, but s3? solr? memcached? Are all of these things datastores?
Of course you know what I think. One of the really interesting things about the NoSQL movement is that they’ve expanded our definition of a datastore. Does anyone remember those guys in the 90s that were writing big Java apps and persisting stuff in XML text files? Was anyone here one of those guys?
Those guys were doing NoSQL...before it was coool.
But big problem #1 with a system like this is....
How do you encapsulate all of these disparate data stores into a model class that makes sense? What does it look like?
So that’s question 1, keep that in mind.
There’s another question, too...
How do you go from this...
...to this? How do you replace your primary datastore with something else? All of these data stores we’ve been looking at so far have been satellites to the primary which was SQL. But if you’re lucky, and very successful, you’ll need to replace it with something else.
Digg, for example, just moved over to Cassandra! For everything! Of course this is not always the right answer, because shortly after Digg rolled out their new architecture, they fired their VP of engineering, ... so...
But if you want to do it, and sometimes you do, historically, this has been pretty difficult to do in Rails.
That’s question 2 - how do you replace your primary datastore?
In reality, rather than this kind of thing, where all you have is Cassandra and no SQL-based storage at all, ...
Most apps use a hybrid approach. They use standard SQL persistance for some things, because there IS data that’s suited for, such as basic CRUD stuff.
Then they use non-SQL persistence for other things, where it fits. I mean, you can keep cassandra for your voluminous sparse data...if you have that, and a surprising number of apps do!
So here are the two interesting questions we have when we’re building a system that uses multiple datastores:
So just to sum up this section, this idea that multiple datastores are a fact of life if you’re building even simple applications is called polyglot persistence.
It’s not a new idea - Ben Scofield has been talking about it for more than a year. But a lot of Ruby developers think of “the data storage layer” and they think it’s a choice between MySQL and Postgres, when in reality, it’s going to end up with an assortment of different technologies. Whether or not they want that, and whether or not they explicitly plan for it.
So let’s take a look at what that’s going to look like.
Let’s start with the base case - I decided for my sample application I would build a cephalopod social network, mostly because I like the word cephalopod. So here we’re starting out with a basic Squid class. We’re inheriting from ActiveRecord::Base so we get the relational introspection and stuff for free.
Then our product owner comes along and tells us that customers want to free-text search the set of squids. So, we install sunspot, and add solr free-text search by adding a “searchable” block describing which attributes get indexed in solr.
And then of course since it’s a web application, we have to have a friend graph. So we decide to store a denormalized list of each squid’s friends in redis. This probably wouldn’t be the first solution I settled on, but pretend with me that I’ve already tried storing this in MySQL and encountered the pain of horrendous joins. I’ve realized that this type of relationship data just doesn’t fit into a row-centered relational datastore very well, so I’m trying something else.
So I add a “follow” method that uses the astonishingly-descriptively-named “redis” gem to insert stuff into a redis keyspace.
And then, of course, since this is a social network centered around cephalopods and the novels they write, I want to allow them to upload a finished manuscript to s3. So I install the, again, very usefully-named s3 gem, and add an upload_novel method that puts the tex file into s3.
Current datastore count: 4
Now at this point, the Squid class is started to look a little...
...mismatched.
You’re descending from ActiveRecord::Base, but you’ve got this searchable method from solr, plus you’ve got this follow method from redis, plus an upload method that uses s3, plus the magic hidden ActiveRecord methods. Each of these things persists a little piece of the whole squid.
You know what I would like? Some kind of consistent interface.
Now you may laugh, but I originally thought it would be awesome to be able to do everything through ActiveRecord. It’s very tempting! Most of us who use Rails think of ActiveRecord as synonymous with “model.”
It’d be awesome to have everything go through one interface. Active Record - it’s my model of all my data stores! My code lives happily on top!
But, sadly, it just doesn’t work that way. And it’s not going to. This is not because Rails core is trying to make our lives difficult. It’s because ActiveRecord is specifically built to model a relational database. It’s an ORM, which means Object-Relational Mapper. In fact, in Rails 3, ActiveRecord moves even more in that direction with Arel, which is, conceptually, an implementation of the theory of a relational database. This is called relational algebra. There’s a whole talk on it tomorrow! It’s awesome! It’s cool. It’s conceptually very consistent, easy to understand, and very tidy, all of which appeal to me.
Unfortunately, relational algebra is totally useless with a non-relational datastore where you don’t structure your data into rows, and columns, and tables. It just doesn’t map to something like a key-value store like redis, or column-oriented document database like mongo.
But once I started looking at Rails 3, I got very happy. The folks who rewrote it realized, correctly, that ActiveRecord in Rails 2 was modelling two very different types of behavior.
Here’s what we have in Rails 2: a big, blobby ActiveRecord that does both the communication with the database, and lots of other useful stuff like validations and lifecycle callbacks - stuff your calling code uses, but that isn’t directly related to how the data is persisted.
So in Rails 3 they’ve split this up into two separate libraries: ActiveRecord that handles persistance, and ActiveModel that handles validations and callbacks.
A lot of the blog posts and stuff about ActiveModel have talked about how this makes it easier to take validations and serialization and so on from ActiveModel and use them in plain old Ruby objects outside of Rails.
But as someone who does mostly Rails development, I actually don’t really care about that. What I’m excited about is that it’s now much easier to extract ActiveRecord from your models in Rails. It makes it much easier to write an adapter for a non-relational datastore and be able to use it in your models in a Rails app. All you have to do is present the same API to ActiveModel that ActiveRecord does, and that’s actually pretty easy. And in fact,
There are already several ActiveModel-compliant persistance libraries out there for accessing these things, like mongoid by Durran Jordan. So, you actually can, sort of, have a similar interface for different persistance models in Rails 3. Now, this doesn’t really solve the problem of multiple stores in one model, but it does make it possible to keep a lot of the niceties of what was previously “ActiveRecord” without actually persisting to a relational database. And that’s pretty hot!
Now that it’s getting easier to use a nonrelational store, I think we’re going to start seeing a lot more applications take advantage of them.
Here are a few of the extant ActiveModel-compliant libraries. Most of them are quite alpha and experimental. But expect to see more, and see them mature.
Here’s the basic setup. In Rails 3 we no longer inherit from ActiveRecord::Base, so the models are nicely decoupled from any default datastore. Here we’re defining Mongo as our primary store.
Sadly, ActiveModel doesn’t solve all of our problems. We still have to work at it to use more than one datastore within the same model.
For instance,
to add solr search we still need a searchable block. However, UNLIKE in Rails 2, this will still work no matter what primary persistance we use. It uses on the lifecycle methods that are part of ActiveModel. In Rails 2 they were so tightly coupled with ActiveRecord that you pretty much couldn’t use them separately.
So coming back to our 2 questions from the beginning of the talk, which were: how do you encapsulate a model that has data scattered across multiple stores, and how do you replace the primary store...
Sadly, the first one - not really solved yet. The best you can do is break stuff into modules where possible, and try to extract the common bits. No silver bullet here, just general good software engineering.
But the second one
...is fully solved in Rails 3. I’m actually really excited by that and it’ll be interesting to see which ActiveModel-compliant libraries gain traction.
And I’d like to close with this thought: if you do is read all the blogs and twitter, you might think SQL vs. NoSQL is some kind of standoff, and that you have to be on one side or the other. Either you’re the guys in yellow, or you’re the guys in blue.
But that’s a false dichotomy. Any application with more than a hundred users will use both. So please: quit it with the FUD, and look for ways they can place nice together.
AND, if you’re going to do this, upgrade to Rails 3!