Sascha Möllering gave a presentation on deploying applications to the AWS cloud. He began with an overview of AWS services like EC2, S3, RDS and explained how to initially create a simple cloud service with one instance each for a web application and database. He then described how to improve the architecture by separating components, adding redundancy and elasticity using services like ELB, autoscaling and read replicas. Sascha demonstrated deploying a sample application built with JHipster and Docker to AWS Elastic Beanstalk, which handles running the containers and mapping environment variables for the database connection.
Drupal commerce performance profiling and tunning using loadstorm experiments...Andy Kucharski
Drupal commerce performance profiling by load testing a the kickstarter drupal commerce site on an AWS instance and comparing how the site performa after several well known performance tuning enhancements are applied. We try to compare performance improvements after druapl cache, aggregation, varnish, and nginx reverse proxy.
This presentation was first given at Drupal Mid Camp in Chicago. We used loadstorm and new relic to analyze results.
Performance and scalability with drupalRonan Berder
This document discusses strategies for improving the performance and scalability of Drupal websites. It recommends analyzing bottlenecks, optimizing web servers, application servers, and databases, adding caching, using reverse proxies, optimizing code, and incrementally adding complexity. Specific optimizations mentioned include cleaning configurations, removing unnecessary modules, adding opcode caching, switching to Nginx/PHP-FPM, using memcache, optimizing queries, profiling code, and caching anonymous traffic. The document emphasizes that code optimization is a major part of performance.
DrupalCampLA 2014 - Drupal backend performance and scalabilitycherryhillco
This document discusses various techniques for optimizing Drupal backend performance and scalability. It covers diagnosing issues through tools like Apache Benchmark and Munin, optimizing hardware, web and database servers like using Nginx, Varnish, MySQL tuning, and alternative databases like MongoDB. It also discusses PHP optimizations like opcode caching and HHVM. The goal is to provide strategies to handle more traffic, improve page response times, and minimize downtime through infrastructure improvements and code optimizations.
The Scala programming language has been gaining significant traction over the last few years, being adopted by vastly different organizations from startups to large enterprises. While the language itself is pretty well understood and explained in tutorials and books, there is an apparent dearth of practical advice for new adopters on the best approach to integrating the new technology. In this talk I’ll attempt to offer such advice gathered over several years of production Scala use, focusing on tools, practices, patterns and the community, in the hope of making your transition into the Scala ecosystem easier and better-informed up front.
A talk given at JavaOne 2015 in San Francisco.
Configuring and maintaining a continuous integration environment is quite a bit of work. It requires ongoing resources both in terms of manpower and hardware infrastructure. As an application evolves so does the number of ongoing projects. The challenge is creating a scalable continuous integration environment which does not impede development and can handle the complexities of Java EE testing. This session covers how to setup and configure a cloud-based continuous integration environment for Java EE applications.
The presentation will focus on demonstrating how to use Atlassian Bamboo running on AWS to build and test a Maven/Gradle Java EE project that uses Arquillian for testing. Topics that will be covered include creating a custom AWS VM for use with Bamboo, creating an Amazon VPC (Virtual Private Cloud) along with test database using Amazon RDS. The presentation will delve into the specifics of testing EJBs, WebSocket endpoints, RESTful web services, as well as performing load testing in this environment. Security, cost control, and build monitoring will be covered as well.
Redis is an in-memory key-value data store that can be used for caching, sessions, queues, leaderboards, and more. It provides fast performance due to being memory-resident and supporting different data structures like strings, hashes, lists, sets, and sorted sets. Redis is useful for read-heavy and real-time applications but may not be suitable if data does not fit in memory or for relational data needs. The presentation discusses using Redis with PHP and Symfony, data sharding strategies, and war stories from a social game with 7.5M daily users.
Michael North "Ember.js 2 - Future-friendly ambitious apps, that scale!"Fwdays
Ember.js is being adopted more and more broadly as time passes, and is an excellent choice for highly complex data-driven UIs. With the recent release of the "2.0" version of the framework, things are faster, smarter, and easier than ever. With a focus on productivity and reducing the number of trivial decisions developers must make while building an app, it's astonishing how quickly one can get up and running, and how well the abstractions hold up as the codebase scales in size and complexity.
I'd like to give a general overview of Ember, and pause to reflect on some important differences that may be important when considering what the best tool is for your project.
Akka is an open source toolkit for building highly concurrent, distributed, and fault-tolerant applications on the JVM. It uses the actor model and software transactional memory to provide a higher level of abstraction for writing scalable applications compared to lower-level concurrency primitives. Akka embraces the "let it crash" model of fault tolerance used in telecom to build self-healing systems and aims to make building reliable distributed systems easier.
This document provides an overview of a presentation given at CamelOne 2013 in Boston on June 10-11, 2013 about the internals of Apache ActiveMQ. The presentation covered the major subcomponents of ActiveMQ including transports, the broker core, persistence adapters, and networking brokers. It provided details on architecture, configuration, and implementation of these different aspects of ActiveMQ.
Drupal High Availability High Performance 2012Amazee Labs
This document discusses strategies for achieving high availability and high performance with Drupal. It recommends using redundant web and database servers, load balancers, caching with Varnish and Memcache, and a distributed file system like GlusterFS. MySQL master-slave replication is suggested for database redundancy. The goal is a scalable system with no single point of failure and fast response times.
This document discusses how to avoid getting lost in the current JavaScript landscape. It begins by looking at modern web development trends like HTML5, CSS3, ES6, and expectations of fast page loads. It then examines traditional page lifecycles versus single page applications and various JavaScript frameworks. The document advocates for progressive enhancement and outlines strategies like "Hijax" and using the HTML5 History API to improve traditional approaches. It also discusses issues like code duplication, the benefits of isomorphic JavaScript, and tools for frontend development including Grunt, Gulp, asset bundlers, and test runners. It concludes by providing recommendations on technologies to adopt, consider, or stop using to develop with a progressive enhancement approach.
Alfresco DevCon 2019 Performance Tools of the TradeLuis Colorado
Discover tips and tools that will help you to keep your Alfresco environment in shape. Most of the best tools are free or Open Source, and this presentation will guide you through the steps to improve the performance of your system.
Scaling out a web application involves adding redundancy, separating application tiers across multiple servers, implementing load balancing, caching content, and monitoring performance. Key aspects include mirroring disks for redundancy, moving services to separate application servers, using load balancing schemes like DNS round-robin or load balancers, solving session state issues through sticky routing or database storage, and caching dynamic content to improve performance. Monitoring the environment is also important to detect failures or bottlenecks as the infrastructure scales out.
This document discusses technologies for creating and maintaining web applications. It covers Ruby and the Rails framework. Ruby is designed to be programmer-focused rather than machine-focused, helping create dynamic and self-explained code. Rails enables quickly building web servers through conventions, reuse, single responsibility principles, and features that provide quick setup, deployment, and built-in scalability. The document also discusses front-end architecture with client-side logic, and Rails features for development, deployment, databases, assets, and multi-environment configuration.
The document provides an overview of the modern JavaScript ecosystem. It discusses the main execution environments (browsers, Node.js, io.js), web servers (Express, Hapi, Koa), package managers (NPM, Bower), task runners (Grunt, Gulp, Broccoli), front-end frameworks (jQuery, Backbone, Angular, Ember, React), module systems (AMD, CommonJS, ES6 modules), and JavaScript flavors/transpilers (CoffeeScript, TypeScript, Dart, ES6). It also outlines the typical development workflow from writing code to compilation/packaging to deployment on a web server to usage in a browser.
Writing microservices in Java -- Chicago-2015-11-10Derek Ashmore
This document summarizes a presentation on writing microservices in Java. It discusses:
- What microservices are and common traits like single functional purpose and standard interfaces
- Reasons for using microservices like no lock-in, easier management, and higher throughput
- Design considerations like service boundaries, handling failures, data integrity, and performance
- Common patterns for designing microservices around failures, transactions, and performance
- Cross-cutting concerns like deployment, security, and contract testing
- When microservices are appropriate to use
The presentation provides examples and references additional resources on GitHub for sample code.
Aws Lambda for Java Architects - Illinois VJug -2016-05-03Derek Ashmore
Derek C. Ashmore gave a presentation on AWS Lambda for Java architects. He began with an introduction of himself and his background. The presentation covered what AWS Lambdas are, their benefits and limitations. It discussed developing Lambda functions using the RequestHandler interface in Java and provided examples. It also covered supporting Lambda functions through services like API Gateway and resources like logging. Finally, it discussed using Lambdas for microservices and provided best practices.
Write Once, Run Everywhere - Ember.js MunichMike North
The document discusses building applications that can run everywhere using Ember.js and Electron. It introduces Electron and how it allows packaging Ember apps with Chromium for desktop distribution. It also covers using Ember addons to integrate Cordova and native device capabilities. The document demonstrates building a sample Ember app that uses routing, components and animations, and packaging it into a desktop app with Electron.
The document discusses various JVM web frameworks including Play, Ratpack, Spring Boot, and Rails. It provides code examples for templating, databases, servers, and other aspects of each framework. It compares the strengths and weaknesses of frameworks like Play, Ratpack, and Spring Boot. It emphasizes that modern JVM web development uses languages like Scala, Groovy, JRuby and Clojure rather than traditional Java web apps with WAR files. The document encourages the audience to pick a framework like Play, Ratpack or Rails and provides the basic commands to create a new project in each.
Database Programming with Perl and DBIx::ClassDave Cross
The document provides an overview of a training course on database programming with Perl and DBIx::Class. It discusses relational databases and concepts like relations, tuples, attributes, primary keys and foreign keys. It then covers how to interface with databases from Perl using the DBI module and drivers. It introduces object-relational mapping and the DBIx::Class module for mapping database rows to objects. It shows how to define DBIx::Class schema and result classes to model database tables and relationships.
Perl is a general-purpose programming language created by Larry Wall in 1987. It supports both procedural and object-oriented programming. Perl is useful for tasks like web development, system administration, text processing and more due to its powerful built-in support for text processing and large collection of third-party modules. Basic Perl syntax includes variables starting with $, @, and % for scalars, arrays, and hashes respectively. Conditional and looping constructs like if/else, while, and for are also supported.
The document provides an overview of a Perl training session, covering topics like Perl introduction, variables, operators, control structures, regular expressions, and file input/output. The agenda is split into two parts - the first part covers basics of Perl like variables, I/O functions, and control statements. The second part focuses on regular expressions, file I/O, and installing modules. The document also includes detailed descriptions of various Perl concepts.
The document provides an overview of the topics that will be covered in a training session on modern Perl techniques. The session will cover Template Toolkit for templating, DateTime and related modules for handling dates and times, DBIx::Class for object-relational mapping, TryCatch for exception handling, Moose for object-oriented programming, and additional modules like autodie and Catalyst. The schedule includes sessions, breaks for coffee and lunch, and resources for following up after the training.
This document summarizes the key requirements and implementation of a project to display the HTML5 logo with accompanying text:
- The logo is drawn on a canvas element using JavaScript to draw paths and text. Coordinate transformations are used to position the different elements.
- Accompanying text uses semantic HTML tags and includes hyperlinks. A footer provides attribution and references.
- Users can adjust the size of the logo using a range slider input, though Firefox currently does not fully support this element.
- The project combines drawing on a canvas, coordinate transformations, semantic HTML elements, and an interactive element to provide an example that reviews important HTML5 and JavaScript concepts. Limitations across browsers are also demonstrated.
The document discusses various techniques for querying databases and generating reports from the query results using Perl. It provides examples of using DBI and SQL to query databases and format output, techniques for binding variables, preparing queries, and fetching and printing rows. Additional examples show merging and transforming tabular data for different output formats.
This document provides an overview of an advanced Perl DBI tutorial. It discusses various topics related to improving performance when working with databases using the Perl DBI module. These include speeding up queries by reducing round trips to the database, using prepared statements and caching, understanding query planning and optimization, and how to influence query plans through hints. It also provides examples of explaining query plans in MySQL and Oracle. The document is intended to help attendees of a conference tutorial understand performance techniques when working with databases in Perl.
An overview of the main questions/design issues when starting to work with databases in Perl
- choosing a database
- matching DB datatypes to Perl datatypes
- DBI architecture (handles, drivers, etc.)
- steps of DBI interaction : prepare/execute/fetch
- ORM principles and difficulties, ORMs on CPAN
- a few examples with DBIx::DataModel
- performance issues
First given at YAPC::EU::2009 in Lisbon. Updated version given at FPW2011 in Paris and YAPC::EU::2011 in Riga
This document provides instructions on installing and configuring MySQL on Linux. It discusses downloading and installing the MySQL RPM package, setting the root password for security, starting the MySQL server and client, and running basic queries to test the installation. It also covers additional MySQL commands and configurations including user privileges, database design, backups, and restoring data.
This document provides an overview and schedule for a one-day introduction to Perl programming course. It covers what will be taught including creating and running Perl programs, variables, operators, functions, input/output, and more. The schedule includes breaks and lunch and notes resources available online for the slides.
My Beginners Perl tutorial, much abbreviated and as presented at the London Perl Workshop on Dec 1st 2007.
Also includes the section on Regular Expressions that we didn't have time for on the day.
- The document discusses various aspects of Unix programming using Perl, including handling errors, filehandles after forking processes, and signals.
- It provides examples of how to properly check for errors, avoid resource collisions after forking, and make code cancellable using signals.
- Key topics covered include using the Errno module to check for errors, closing filehandles after forks to prevent sharing issues, and trapping signals like SIGPIPE and SIGTERM.
SmugMug: From MySQL to Amazon DynamoDB (DAT204) | AWS re:Invent 2013Amazon Web Services
SmugMug.com is a popular hosting and commerce platform for photo enthusiasts with hundreds of thousands of subscribers and millions of viewers. Learn now SmugMug uses Amazon DynamoDB to provide customers detailed information about millions of daily image and video views. Smugmug shares code and information about their stats stack, which includes an HTTP interface to Amazon DynamoDB and also interfaces with their internal PHP stack and other tools such as Memcached. Get a detailed picture of lessons learned and the methods SmugMug uses to create a system that is easy to use, reliable, and high performing.
Building resilient serverless systems with non serverless componentsJeremy Daly
Serverless functions (like AWS Lambda, Google Cloud Functions, and Azure Functions) have the ability to scale almost infinitely to handle massive workload spikes. While this is a great solution for compute, it can be a MAJOR PROBLEM for other downstream resources like RDBMS, third-party APIs, legacy systems, and even most managed services hosted by your cloud provider. Whether you’re maxing out database connections, exceeding API quotas, or simply flooding a system with too many requests at once, serverless functions can DDoS your components and potentially take down your application. In this talk, we’ll discuss strategies and architectural patterns to create highly resilient serverless applications that can mitigate and alleviate pressure on “non-serverless” downstream systems during peak load times.
SQL Azure for ISUG(SQL Server Israeli User Group)Pini Krisher
This document provides an overview of SQL Azure and discusses key topics including:
- What is Platform as a Service (PaaS) and how SQL Azure fits within Azure's PaaS offerings.
- Key aspects of SQL Azure including the portals, performance tiers, versions, security features, limitations compared to on-premise SQL Server, pricing, and pros/cons.
- Additional Azure data services like Storage, Virtual Machines, DocumentDB, Tables, Hadoop, and BI.
The View - Leveraging Lotuscript for Database ConnectivityBill Buchan
The document discusses using LotusScript (LS) to connect Lotus Notes databases to external relational databases. It covers LSX, LS:DO, and DCR as methods for database connectivity from LotusScript server-side agents. The presentation provides code examples and discusses object-oriented design patterns for database connectivity classes. It demonstrates connecting to an Access database using ODBC and connecting to an Oracle database from LotusScript. The document emphasizes best practices like error handling, logging, and separating database-specific code.
The document provides an introduction and agenda for an HBase presentation. It begins with an overview of HBase and discusses why relational databases are not scalable for big data through examples of a growing website. It then introduces concepts of HBase including its column-oriented design and architecture. The document concludes with hands-on examples of installing HBase and performing basic operations through the HBase shell.
Project Voldemort is a distributed key-value store inspired by Amazon Dynamo and Memcached. It was originally developed at LinkedIn to handle high volumes of data and queries in a scalable way across multiple servers. Voldemort uses consistent hashing to partition and replicate data, vector clocks to resolve concurrent write conflicts, and a layered architecture to provide flexibility. It prioritizes performance, availability, and simplicity over more complex consistency guarantees. LinkedIn uses multiple Voldemort clusters to power various real-time services and applications.
MariaDB: in-depth (hands on training in Seoul)Colin Charles
MariaDB is a community-developed fork of MySQL that aims to be a drop-in replacement. It focuses on being compatible, stable with no regressions, and feature-enhanced compared to MySQL. The presentation covered MariaDB's architecture including connections, query caching, storage engines, and tools for administration and development like mysql, mysqldump, and EXPLAIN.
Moving Windows Applications to the CloudRightScale
This document summarizes a webinar about moving Windows to the cloud. It discusses:
- Key differences between Windows in the cloud vs on-premises like dynamic IP addresses, ephemeral instances, and bringing your own licenses.
- Challenges of Windows in the cloud like inconsistent images, inflexible pre-installed software, and lack of automation.
- How RightScale addresses these with consistent "RightImages", scriptable and versioned "ServerTemplates", and automation of deployments using "RightLink".
- A demonstration of automating user creation across servers using RightLink tags and remote execution.
- Next steps involve scripting application installation, enabling existing Windows images with Right
ScaleBase Webinar: Scaling MySQL - Sharding Made Easy!ScaleBase
Home-grown sharding is hard - REALLY HARD! ScaleBase scales-out MySQL, delivering all the benefits of MySQL sharding, with NONE of the sharding headaches. This webinar explains: MySQL scale-out without embedding code and re-writing apps, Successful sharding on Amazon and private clouds, Single vs. multiple shards per server, Eliminating data silos, Creating a redundant, fault tolerant architecture with no single-point-of-failure, Re-balancing and splitting shards
IBM Connections – Managing Growth and ExpansionLetsConnect
You are lucky, your Connections platform is experiencing rapid growth – now what? How to you determine when you have grown to where you need to build out the service? How do you grow WebSphere or the File Service Space? How do you add additional Web Servers or is it better to add a proxy server? Learn how to judge and decide what you need to change – and how to then implement it.
This document summarizes a presentation about optimizing server-side performance. It discusses measuring performance metrics like time to first byte, optimizing databases through techniques like adding indexes and reducing joins, using caching with Memcached and APC, choosing fast web servers like Nginx and Lighttpd, and using load testing tools like JMeter to test performance before deployment. The presentation was given by a senior engineer at Wayfair to discuss their experiences optimizing their platform.
MySQL Performance Tuning. Part 1: MySQL Configuration (includes MySQL 5.7)Aurimas Mikalauskas
Is my MySQL server configured properly? Should I run Community MySQL, MariaDB, Percona or WebScaleSQL? How many innodb buffer pool instances should I run? Why should I NOT use the query cache? How do I size the innodb log file size and what IS that innodb log anyway? All answers are inside.
Aurimas Mikalauskas is a former Percona performance consultant and architect currently writing and teaching at speedemy.com. He's been involved with MySQL since 1999, scaling and optimizing MySQL backed systems since 2004 for companies such as BBC, EngineYard, famous social networks and small shops like EstanteVirtual, Pine Cove and hundreds of others.
Additional content mentioned in the presentation can be found here: http://speedemy.com/17
Building Resilient Serverless Systems with Non-Serverless ComponentsJeremy Daly
Serverless functions (like AWS Lambda, Google Cloud Functions, and Azure Functions) have the ability to scale almost infinitely to handle massive workload spikes. While this is a great solution to compute, it can be a MAJOR PROBLEM for other downstream resources like RDBMS, third-party APIs, legacy systems, and even most managed services hosted by your cloud provider. Whether you’re maxing out database connections, exceeding API quotas, or simply flooding a system with too many requests at once, serverless functions can DDoS your components and potentially take down your application. In this talk, we’ll discuss strategies and architectural patterns to create highly resilient serverless applications that can mitigate and alleviate pressure on non-serverless downstream systems during peak load times.
This document discusses moving a web application to Amazon Web Services (AWS) and managing it with RightScale. It outlines the challenges of the previous single-server deployment, including lack of scalability and single point of failure. The solution presented uses AWS services like EC2, S3, EBS and RDS combined with RightScale for management and Zend Server for the application architecture. This provides auto-scaling, high availability, backups and easier management compared to the previous setup. Alternatives to AWS and RightScale are also briefly discussed.
This presentation, given by Dave Rosenthal at NoSQL Now! 2013, presents the case for why he believes NoSQL databases will need to support ACID transactions in order for developers to more easily build, deploy, and scale applications in the future.
Production NoSQL in an Hour: Introduction to Amazon DynamoDB (DAT101) | AWS r...Amazon Web Services
Amazon DynamoDB is a fully managed NoSQL database service provided by AWS that provides fast and predictable performance with seamless scalability. It offers a flexible data model and reliable access patterns. With DynamoDB, users do not need to provision, operate, or scale their own database clusters and can instead pay only for the storage and throughput capacity they need.
Cassandra Summit 2014: Deploying Cassandra for Call of DutyDataStax Academy
Presenters: Seán O Sullivan, Service Reliability Engineer & Tim Czerniak, Software Engineer at Demonware
This presentation covers the eight-month evaluation process we underwent to migrate some of Call of Duty’s core services from MySQL to Cassandra. We will outline our requirements, the process we followed for the evaluation, decisions we made around our schema, configuration and hardware, and some issues we encountered.
Framing the Argument: How to Scale Faster with NoSQLInside Analysis
The Briefing Room with Dr. Robin Bloor and IBM Cloudant
Live Webcast March 24, 2015
Watch the Archive: https://bloorgroup.webex.com/bloorgroup/onstage/g.php?MTID=e8bf62408d47e76c43aa73be08377e41c
Context matters. Perspective matters. Thinking outside the box? That's often the key! While the Structured Query Language remains the lingua Franca of data, there are some views of the world that are best rendered with the benefit of NoSQL engines. As usual, that's easier said than done. How can your organization migrate from a structured query to unstructured or semi-structured query language?
Register for this episode of The Briefing Room to find out! Veteran Analyst Dr. Robin Bloor will provide a detailed assessment of serious considerations when using NoSQL engines in conjunction with SQL. He'll be briefed by Ryan Millay of IBM Cloudant, who will showcase his company's solution, and how it's addressing the more vexing challenges facing today's information managers.
Visit InsideAnalysis.com for more information.
Similar to High Availability Perl DBI + MySQL (20)
Simon Wardley gifted his research & ideas to the world over a decade ago, and he wants society to benefit from them for decades to come.
Let's start a Wardley Mapping Foundation to help him carry the load!
This document discusses organizing a company using service-based structures and Wardley maps. It includes examples of mapping out a company's services, value chains, metrics, user needs, and more. Key points discussed are:
- Modeling the company as a network of independent, self-managing services rather than rigid hierarchies
- Using Wardley maps to visualize each service's evolution over time from custom to commodity
- Service agreements, budgets, and other contracts playing an important role in governing relationships between services
- Mapping both formal power structures and informal relationships to understand dependencies and flow of value/capital
First delivered as a guest speaker at Mark Esposito's System & Complexity Thinking course at Hult University, June 2021.
This talk is aimed at people learning about complex systems with a background in organisational design & management. It looks at the difference between Computational Complexity and Applied Social Complexity, touches on the limits of Computation, Business Processes, & Systems Thinking, and introduces two frameworks that can be used to help organisations understand their current context and navigate more effectively.
Most content in the notes.
A whirlwind tour of Glasswall Solution’s use of Wardley Maps and experiments with a Service-based operating model. Delivered at Open Security Summit Dec 7th, 2020 as context for a panel discussion, which you can watch here:
https://www.youtube.com/watch?v=GS8Vndr-B4A
The original 100-slide deck is available here:
https://open-security-summit.org/tracks/2020/mini-summits/dec/wardley-maps/wardley-maps-and-services-model-at-glasswall/
What do Wardley Maps mean to me? (Map Camp 2020)Steve Purkis
At Map Camp 2020, I was asked to do a short talk on "What Wardley Maps mean to me?", as part of a trio with Sue Borchardt and Kaimar Karu. I'll dig up links to their talks (and Sue's fantastic drawings!) once published.
Here, I touch on how I got started with Wardley Maps in the early days, and what I've been doing with them recently, including:
* Covid as a forcing function
* The impact of Inertia / Apex Predator complacency
* How Glasswall OpenSource is using Wardley Maps
* Cell-based organisational structures with OSOM
* How we're helping Simon's ongoing research on Doctrine
* GCATI's effort to introduce Mapping Standards
* Some links between Cynefin & Wardley Maps
Oh, and I've snuck into the Appendix something on Mapping the UN's Sustainability Development Goals.
Enjoy! :-)
This introduction to Strategy with Wardley Maps covers:
* What is Wardley Mapping?
* The Problem & Value of Mapping
* Elements of a Map
* Overview of the Strategy Cycle
* A couple of Climatic Patterns
* Several examples
First run @ Wardley Maps London September 2020 as a talk + workshop. https://www.meetup.com/Wardley-Maps-London
Recording will be posted soon.
It is released CC-by-SA, and is based on Simon Wardley's work available on https://medium.com/wardleymaps
COVID-19 - Systems & Complexity Thinking in ActionSteve Purkis
First delivered at Mark Esposito's Systems Thinking course at Harvard, April 2020.
This talk examines various responses to the COVID-19 pandemic, focusing on economic & social impacts (less on the medical side), with the goal of introducing complexity thinking to organisational strategy.
It introduces complexity thinking using Dave Snowden’s Cynefin framework and demonstrates how system loops evolve in the complex domain as a result of safe-to-fail probes. It introduces Simon Wardley’s value chain mapping technique, and shows how organisations can use it to scan for exaptive opportunities as they are making sense of the chaos. Finishes with a still-evolving early view of the macro/mega response of governments, the looming threat of climate change, and the importance of metrics & diversity in system evolution.
How will our economic & social system evolve?
Predicting & Influencing with Kanban MetricsSteve Purkis
Your project’s going off the rails! You’re not sure if you’ll be able to deliver everything the client wants in the time they can afford. Your team is great, but you still can't help the feeling you could be performing better…What do you do?
Don’t wait for it to go wrong to introduce metrics!
In this session, Steve Purkis and Adam Scott will explore some of the Lean Kanban metrics they've used with clients over the past few years. They'll look at how the metrics evolved over time, what worked and what didn't, and show how the metrics were used to predict and influence delivery. This practical talk is based on a wide range of scenarios from real-world experiences and is aimed at both delivery teams and stakeholders looking for ideas on how to encourage the right behaviours to get the best for their organisations.
First presented at P3X in London, Nov 2018.
Map Your Values: Connect & CollaborateSteve Purkis
Why do you get out of bed every day? Why do you go to work? When it comes down to it, what’s really important to you?
Understanding what makes you tick can have a transformative impact on your life, improving your sense of agency and leading a more fulfilling life. Understanding what makes those around you tick can have a transformative impact on your relationships, enabling you to communicate and collaborate more effectively.
In this workshop, you’ll learn how to map your values and practice communicating them effectively to each other. You’ll examine what happens when your values are compromised, prioritise them, and compare them to your organisation’s values. Finally, you’ll consider how you can increase the chances of fulfilling your values.
Participants may want to bring their notebooks, and something to take pictures with.
An overview of Joshua Kerievsky’s "Modern Agile", used to generate some interesting discussion at Agile Ottawa in Feb 2016.
Based on Joshua's work:
* blog: https://www.industriallogic.com/blog/modern-agile/
* webcast: http://leankit.com/blog/2015/12/modern-agile/
This is an introduction to Kanban as a Lean Method, for people new to the idea. Its goals are to demonstrate how Kanban can be used to:
1. Visualise Processes
2. Apply Limits
3. Make Improvements
I prepared it for the Gatineau-Ottawa Agile Tour 2015 (http://goagiletour.ca).
It has a number of activities and is meant to be run as an interactive workshop to engage the audience. Feel free to use it yourself, or contact me if you'd like to arrange a session.
Writing a Space Shooter with HTML5 CanvasSteve Purkis
This talk reviews a Space Shooter game that I wrote to learn about HTML5 canvas. It covers:
* Basics of canvas 2D
* Overview of how the game is put together
* Some performance tips
First presented @ Ottawa JavaScript in September 2012.
This document summarizes the Scalar::Footnote Perl module. Scalar::Footnote allows you to attach hidden scalars called "footnotes" to references. You can set and retrieve these footnotes without affecting the original objects. Under the hood, it uses Perl's internal magic system to attach the footnotes to references in a way that is invisible to the user. The module has been tested and is available on CPAN.
The document describes the Test Anything Protocol (TAP), which is a standard format for representing test results. It discusses the structure and grammar of TAP, provides examples of TAP output, and notes that TAP is used by many testing frameworks across multiple programming languages. The document is intended to provide an overview of TAP for an audience that includes discussing how TAP is used with continuous integration systems.
Fluttercon 2024: Showing that you care about security - OpenSSF Scorecards fo...Chris Swan
Have you noticed the OpenSSF Scorecard badges on the official Dart and Flutter repos? It's Google's way of showing that they care about security. Practices such as pinning dependencies, branch protection, required reviews, continuous integration tests etc. are measured to provide a score and accompanying badge.
You can do the same for your projects, and this presentation will show you how, with an emphasis on the unique challenges that come up when working with Dart and Flutter.
The session will provide a walkthrough of the steps involved in securing a first repository, and then what it takes to repeat that process across an organization with multiple repos. It will also look at the ongoing maintenance involved once scorecards have been implemented, and how aspects of that maintenance can be better automated to minimize toil.
Quantum Communications Q&A with Gemini LLM. These are based on Shannon's Noisy channel Theorem and offers how the classical theory applies to the quantum world.
Sustainability requires ingenuity and stewardship. Did you know Pigging Solutions pigging systems help you achieve your sustainable manufacturing goals AND provide rapid return on investment.
How? Our systems recover over 99% of product in transfer piping. Recovering trapped product from transfer lines that would otherwise become flush-waste, means you can increase batch yields and eliminate flush waste. From raw materials to finished product, if you can pump it, we can pig it.
The Rise of Supernetwork Data Intensive ComputingLarry Smarr
Invited Remote Lecture to SC21
The International Conference for High Performance Computing, Networking, Storage, and Analysis
St. Louis, Missouri
November 18, 2021
RPA In Healthcare Benefits, Use Case, Trend And Challenges 2024.pptxSynapseIndia
Your comprehensive guide to RPA in healthcare for 2024. Explore the benefits, use cases, and emerging trends of robotic process automation. Understand the challenges and prepare for the future of healthcare automation
Measuring the Impact of Network Latency at TwitterScyllaDB
Widya Salim and Victor Ma will outline the causal impact analysis, framework, and key learnings used to quantify the impact of reducing Twitter's network latency.
Scaling Connections in PostgreSQL Postgres Bangalore(PGBLR) Meetup-2 - MydbopsMydbops
This presentation, delivered at the Postgres Bangalore (PGBLR) Meetup-2 on June 29th, 2024, dives deep into connection pooling for PostgreSQL databases. Aakash M, a PostgreSQL Tech Lead at Mydbops, explores the challenges of managing numerous connections and explains how connection pooling optimizes performance and resource utilization.
Key Takeaways:
* Understand why connection pooling is essential for high-traffic applications
* Explore various connection poolers available for PostgreSQL, including pgbouncer
* Learn the configuration options and functionalities of pgbouncer
* Discover best practices for monitoring and troubleshooting connection pooling setups
* Gain insights into real-world use cases and considerations for production environments
This presentation is ideal for:
* Database administrators (DBAs)
* Developers working with PostgreSQL
* DevOps engineers
* Anyone interested in optimizing PostgreSQL performance
Contact info@mydbops.com for PostgreSQL Managed, Consulting and Remote DBA Services
BT & Neo4j: Knowledge Graphs for Critical Enterprise Systems.pptx.pdfNeo4j
Presented at Gartner Data & Analytics, London Maty 2024. BT Group has used the Neo4j Graph Database to enable impressive digital transformation programs over the last 6 years. By re-imagining their operational support systems to adopt self-serve and data lead principles they have substantially reduced the number of applications and complexity of their operations. The result has been a substantial reduction in risk and costs while improving time to value, innovation, and process automation. Join this session to hear their story, the lessons they learned along the way and how their future innovation plans include the exploration of uses of EKG + Generative AI.
Choose our Linux Web Hosting for a seamless and successful online presencerajancomputerfbd
Our Linux Web Hosting plans offer unbeatable performance, security, and scalability, ensuring your website runs smoothly and efficiently.
Visit- https://onliveserver.com/linux-web-hosting/
Support en anglais diffusé lors de l'événement 100% IA organisé dans les locaux parisiens d'Iguane Solutions, le mardi 2 juillet 2024 :
- Présentation de notre plateforme IA plug and play : ses fonctionnalités avancées, telles que son interface utilisateur intuitive, son copilot puissant et des outils de monitoring performants.
- REX client : Cyril Janssens, CTO d’ easybourse, partage son expérience d’utilisation de notre plateforme IA plug & play.
Kief Morris rethinks the infrastructure code delivery lifecycle, advocating for a shift towards composable infrastructure systems. We should shift to designing around deployable components rather than code modules, use more useful levels of abstraction, and drive design and deployment from applications rather than bottom-up, monolithic architecture and delivery.
論文紹介:A Systematic Survey of Prompt Engineering on Vision-Language Foundation ...Toru Tamaki
Jindong Gu, Zhen Han, Shuo Chen, Ahmad Beirami, Bailan He, Gengyuan Zhang, Ruotong Liao, Yao Qin, Volker Tresp, Philip Torr "A Systematic Survey of Prompt Engineering on Vision-Language Foundation Models" arXiv2023
https://arxiv.org/abs/2307.12980
Mitigating the Impact of State Management in Cloud Stream Processing SystemsScyllaDB
Stream processing is a crucial component of modern data infrastructure, but constructing an efficient and scalable stream processing system can be challenging. Decoupling compute and storage architecture has emerged as an effective solution to these challenges, but it can introduce high latency issues, especially when dealing with complex continuous queries that necessitate managing extra-large internal states.
In this talk, we focus on addressing the high latency issues associated with S3 storage in stream processing systems that employ a decoupled compute and storage architecture. We delve into the root causes of latency in this context and explore various techniques to minimize the impact of S3 latency on stream processing performance. Our proposed approach is to implement a tiered storage mechanism that leverages a blend of high-performance and low-cost storage tiers to reduce data movement between the compute and storage layers while maintaining efficient processing.
Throughout the talk, we will present experimental results that demonstrate the effectiveness of our approach in mitigating the impact of S3 latency on stream processing. By the end of the talk, attendees will have gained insights into how to optimize their stream processing systems for reduced latency and improved cost-efficiency.
Understanding Insider Security Threats: Types, Examples, Effects, and Mitigat...Bert Blevins
Today’s digitally connected world presents a wide range of security challenges for enterprises. Insider security threats are particularly noteworthy because they have the potential to cause significant harm. Unlike external threats, insider risks originate from within the company, making them more subtle and challenging to identify. This blog aims to provide a comprehensive understanding of insider security threats, including their types, examples, effects, and mitigation techniques.
Understanding Insider Security Threats: Types, Examples, Effects, and Mitigat...
High Availability Perl DBI + MySQL
1. High Availability?
Setting Up MySQL
Our Approach
DBI Framework
Questions
High Availability DBI & MySQL
YAPC::NA 2005
High Availability
DBI & MySQL
Steve Purkis
3. Slide 3
High Availability?
• What is High Availability?
• Ever have an application fail because a
mission critical server crashed?
• High Availability is an attempt to provide
zero application downtime.
4. Slide 4
High Availability?
• How do I achieve HA?:
• Analyze your apps
• Most important components?
• Remove single points of failure (SPOFs):
• Add redundant servers
• Replicate data (backups, realtime)
• Load balancing
• Failover when things go pear-shaped
5. Slide 5
High Availability?
• This talk…
• Introduces one approach to building HA
Perl apps that rely on MySQL.
• We’ve used similar techniques with Oracle
• They work for us…
• They may not be right for you!
8. Slide 8
Setting Up MySQL
• Ye olde basic setup
• Not HA.
Application Server
MySQL
Server
9. Slide 9
Setting Up MySQL
• One master, one read-only slave
• Good for load balancing
• Still not really HA!
Application Server
MySQL
Master
MySQL
Slave Data
Replication
reads writes
Load Balancer
10. Slide 10
Setting Up MySQL
• Two masters
• It’s HA, but…
• Flaky, tricky to work with!
Application Server
MySQL
MasterTwo-way
Replication
MySQL
Master
Load Balancer
11. Slide 11
MySQL
Slave
Setting Up MySQL
• Two masters, multiple slaves
• Only one master active at a time
• HA
Application Server
MySQL
Slaves Data
Replication
reads writes
Primary
Master
2nd
ary
Master
Master Failover
Load Balancer
• HA (unless your hosting center goes down)
12. Slide 12
Setting Up MySQL
• Your HA MySQL architecture will depend on:
• SLAs
• Application requirements
• Load
• Physical spread of servers
• Budget
• Caveats:
• Are your apps read or write heavy?
• Beware of replication lag time
• Common in high-latency networks
• Do your apps need the latest data?
• Transactions?
13. Slide 13
Setting Up MySQL
• Load balancing
• Hardware?
• Software?
• Master Failover
• On Slaves:
CHANGE MASTER TO …
• Manual?
• Automate?
• Cron? Application? SLB?
• On App servers:
• Connect to Secondary
• Not required if using a hot spare w/same ip
14. Slide 14
Setting Up MySQL
• Recommended reading:
• High Performance MySQL
- Jeremey Zawodny & Derek Balling
• MySQL Replication docs
• MySQL Cluster white paper
• For Linux:
• Linux Virtual Server Project
• Linux-HA
17. Slide 17
Our Approach
• Our requirements:
• Read-heavy apps
• Over 750 clients, many with SLAs
• Reliability:
• Read availability most important
• Must work if a server farm goes down
• Speed is of essence:
• Millions of requests a day
• Don’t need transactions
• Minimize costs
19. Slide 19
Farm 2
Farm 3
Farm 1
Our Approach
Application
Server
Application
Server
MySQL
Slave
Application
Server
MySQL
Master
MySQL
2nd
ary
MasterFailover
In-Farm Data Replication
Application
Server
MySQL
Slave
MySQL
Slaves
MySQL
Slave
MySQL
Slaves
Query caching
20. Slide 20
Our Approach
• DBI Framework:
• Load balancing
• Server selection
• Read / Write query?
• Failover
Application
DBI Framework
----------------------------------- snip: how to tell reads from writes? ---------------------------------
my ($action, $dbh) = $query =~ /Aselect|A(select|Ashow|Adesc/i
? ("read", $dbh_read)
: ("write", $dbh_write);
----------------------------------------------------------------------------------------------------------
21. Slide 21
Our Approach
• Load balancing
• On connect
• Weighted server selection
• Availability, number of processes,
user weights, which farm
• MySQL idle timeout
• Failover
• Connect to next slave
• Automatic query retry
Application
DBI Framework
MySQL
Slave
MySQL
Slave
reads
24. Slide 24
DBI Framework
• Two wrapper functions:
• dbconnect( 'read' | 'write' )
• Read: Select slave to connect to
• Write: Connect to all masters
• $sth = sql( $query )
• Read / write dbh selection
• Failover & fallback
• Pseudo code?
25. Slide 25
DBI Framework
• dbconnect( 'read' | 'write' )
• Read:
For each slave
weight = 0, next if can’t ping
check number of processes with mysqladmin
weight = no. processes / user weighting
Connect to slave with lowest weight
Sanity check: run a simple query
Try next slave if that failed
• Write:
For each master
Connect
Sanity check: run a simple query
Set $write_dbh to primary master
26. Slide 26
DBI Framework
• $sth = sql( $query )
• Determine query type…
• Read:
Execute query.
Failover to next slave on error, and retry query.
• Write:
Fallback?
If not using primary, and we failed over X seconds ago, try
reconnecting to master.
Execute query.
Failover to next master on error, and retry query.
31. Slide 31
DBI Frameworks on CPAN
• The ones I know a bit about:
• DBIx::HA
• DBD::Multiplex
• DBIx::DBCluster
32. Slide 32
DBI Frameworks on CPAN
• DBIx::HA
• Generic HA solution
(written & tested for Sybase)
• Configurable by db name (%DATABASE::conf)
• Looks well thought out
33. Slide 33
DBIx::HA
Pros
• Does Failover
• On query failure & dbh
disconnected
• Does timeouts:
• connect, query execute
• Safe signals
• Connect all dsns on init
• Supports Apache::DBI
Cons
• No read / write distinction
• No way to choose which
dbh to use on failover
• (want to use a mysql-
specific algorithm)
• Timeouts with SIGALRM
• (but how else, really?)
• No ping checks for non-
Apache::DBI
• (uses $dbh->ping anyways
- we prefer ICMP ping)
34. Slide 34
DBIx::HA
• Also: written & tested for Sybase!
• Potential DBD::Mysql problems:
• auto_reconnect
we may reconnect to a db when we should be failing over
35. Slide 35
DBI Frameworks on CPAN
• DBD::Multiplex
• send requests to multiple dsn's
• Configure servers to use in $dsn
(pipe-separated list)
36. Slide 36
DBD::Multiplex
Pros
• Supports master/slave
setup:
• differentiates between
reads / writes
• Connects to all dsns
(good for fast master
failover)
• Does failover:
• default behaviour
reads: first_success
writes: first_error
Cons
• Can only specify one
master
• (though if you specify none,
writes can go to all with
'first_error' exit mode)
• Connects to all dsns
• (don't want to connect to all
slaves)
• No customizable slave
failover algorithm
• No reconnects
• No fallback!
37. Slide 37
DBI Frameworks on CPAN
• How could we re-use CPAN modules?
• DBIx::HA
• Sub-class to introduce MySQL specific functionality?
• Introduce a callback for server selection on failover?
• Use in conjunction with DBD::Multiplex for read/write dbh
selection?
• There could be problems though…
• In general:
• Backwards compat
• sql() wrapper (for backwards compat)
• Custom logging?
• Our db wrappers do other things too…
38. Slide 38
DBI Frameworks on CPAN
• Maybe the best way to reuse them is to nick their
ideas?
• DBD::MysqlHA ?
• Combination of DBIx::HA and DBD::Multiplex
• MySQL specific:
• Customizeable server selection algorithm
• Persistent connections
Editor's Notes
Start off by asking who knows what HA is, and get a feel for how much experience they’ve got with HA.
Did your clients notice?
Did you have an SLA?
Were you in bed at the time?
Did you have a backup server?
Did you have a backup of the data?
How long did it take to get the backup server with the backup data back online?
HA for reads, but not for writes.
Due to the way MySQL replication works - conflicting writes (typically auto increment keys)
Mention FS replication
Include further links
Confirm with andrew on # requests a day.
Speak about minimizing costs:
replication across farms.
Query caching run on all slaves out of memory to remove io bottleneck
S/w Loadbalancing
Mention Tear down / setup of connections.
HA dsn:
dsn1: Multiplex to primary master + many slaves
dsn2: Multiplex to secondary master + many slaves
If all slaves go down, will all reads go to master?