Revamped Image Upload: Whys and Hows - Flavio Percoco - OpenStack Day Israel 2016

•

0 likes•134 views

Glance's community has been discussing a new way for doing image uploads. If you've been following the evolution of Glance's API, you'd likely be wondering why is there a need for yet another API for image uploads. Join me in this talk where I'll present the discussions the team has had in the last months, the needs for this new API and how these goals will be achieved.

For attending
Still here
feel free to interrupt
@flaper87flavio@redhat.com

The problem
An user wants to create an image
An OP wants to provide an image
A service needs to create an image

The (real)
problem
Let’s not even talk about “tasks”
Glance uploads are not resilient
Glance doesn’t allow for verification

The (real)
problem
copy-from is gone in V2
Not interoperable
Not discoverable

What do we really want?
interoperability discoverability resiliency

Import
Workflow
must be
Discov
erable
Async
Interop
erable
Well
Defined In summary, the
API must be
discoverable and
allow for async
processing w/o
giving up
interopeability

1. Create
2. Upload
3. Import
3-steps
import

Either direct
or from other
sources
Upload

- Validation
- Conversion
- Nothing (?)
Image
Processing

queued
saving
Uploading
importing
active

1
2
3
4
The entire API will be discoverable
You don’t have to support multi-sources
The old API won’t be removed
DefCore has been part of the design
5 Operating on images on upload: OK!
Summary-ish

1
2
3
4
Yes, there will be two paths for uploads
The task API is deprecated
2 new statuses (uploading, importing)
Backwards compatible
5 We’ll hopefully not f**k this up again
Summary-ish

This document discusses Behavior Driven Development (BDD) using Selenium RC. It introduces BDD and how it can improve the testing process by making tests more clear and involving different roles. It describes how to migrate an existing framework to a BDD structure using keywords to map tests to code. Challenges of this process include managing duplicate keywords and elements, exchanging data between steps, and generating random test data. Standards, reviews and training are recommended to address these challenges.

Common design principles and design patterns in automation testing

KMS Technology

The document discusses common design principles and patterns used in automation testing. It covers the SOLID principles: single responsibility, open/closed, Liskov substitution, interface segregation, and dependency inversion. It also discusses the DRY principle and avoiding duplicate code. For design patterns, it describes the page object model (POM) pattern for organizing web page elements and tests. It also discusses using fluent interfaces with the POM pattern. The presentation provides examples and explanations of how to apply these principles and patterns when writing automation tests.

Promises in JavaScript with jQuery

Ryan Blunden

What I learned teaching programming to 150 beginners

Etiene Dalcol

The document discusses the author's experience teaching 150 beginners programming over 2 hours. They covered basic programming concepts like variables, arrays, loops and functions using JavaScript. The author emphasizes coming prepared with a skeleton code, easy to follow URL, and being ready to answer questions. They also note the importance of inspiring students and finding teaching rewarding, especially when sharing something you're passionate about.

Is your API misbehaving?(Keith-Casey)

Future Insights

Session slides from Future Insights Live, Vegas 2015: https://futureinsightslive.com/las-vegas-2015/ Most API testing is a joke. We have things that resemble Unit Tests which are really integration tests which really just wrap our personal understanding in just a bit of code. And at the end of the day, we’re still not sure it works. Instead, let’s flip the entire experience around and look at it from the API consumer’s point of view and confirm that we’re solving real problems for real users. In this talk, we’ll dive into some of the benefits of Behavior Driven Development and walk through some examples.

Techical Workflow for a Startup

Sébastien Saunier

So you're starting a startup an need best practices for your engineering team. Well, look for: 1. Versionning 2. Branching and Pull Requests (GitHub Flow) 3. Deployment & Continuous Delivery 4. Rollback Strategies 5. Testing 6. Backups 7. Monitoring 8. Communication 9. Issue Tracker / Project Management This deck talks about the tool used by Le Wagon and startup coached by Le Wagon. Le Wagon is the French innovating coding school for entrepreneurs. More info on https://www.lewagon.com

Bdd with Cucumber and Mocha

Atish Narlawar

The document discusses Behavior Driven Development (BDD) and its implementation. It covers BDD topics like the Agile Manifesto, acceptance criteria, Cucumber framework, automation tools like Selenium. It also provides examples of feature files and step definitions in Cucumber. The document advocates that BDD helps align stakeholders, provides executable specifications, and finds defects early through automated tests.

Write Once, Run Everywhere

Mike North

The document discusses building hybrid mobile applications using HTML5 and JavaScript. It recommends using frameworks like Apache Cordova, Ember.js and NW.js to write code once that can run on multiple platforms. The document provides an example case study of building a GitHub organization viewer app with Ember.js that could be deployed to mobile, desktop and the web using these technologies. It outlines setting up models, routes, APIs and responsive design for the app and "hybridifying" it to run on different devices and platforms.

The document discusses feature configuration and A/B testing in mobile apps. It describes how Etsy uses feature flags and continuous experimentation to iteratively develop and test new features. Features can be enabled or disabled for certain users or groups. Experiments follow a process of setting up a feature flag, determining user eligibility, coding the feature, internal testing, then launching the feature to a percentage of users while collecting analytics. This allows gathering feedback to improve products and user experience.

Goodtests

fxsperling

The document discusses best practices for writing good tests, including using tests to specify requirements and document software behavior, refactoring tests to remove duplication, and using test data builders to improve test readability and maintainability. It also notes that tests should be easy to read, test individual features, execute quickly, and provide clear failures to indicate problems. The goal is to write tests that build confidence in software changes without becoming a burden to maintain.

Using The Page Object Pattern

Dante Briones

iOS Testing With Appium at Gilt

Gilt Tech Talks

Automating mobile tests for Gilt's iOS app presented many challenges. While Appium provided a way to write cross-platform tests, implementing full accessibility and mocking complex infrastructure required significant effort. Getting developer buy-in was also difficult as testing was seen as extra work rather than integral to the development process. Overall, mobile testing faced cultural hurdles compared to web.

Handling Changes to Your Server-Side Data Model

Gilt Tech Talks

Enterprise Workflows When You Aren't Enterprise

Chris Tankersley

This document discusses enterprise workflows for software projects and provides recommendations for adopting more enterprise-like practices when resources are limited. It recommends establishing source control, continuous integration, managed environments with separate development, testing, and production stages, and a project management approach like modified waterfall, Scrum, or Kanban. Automating processes and deployments through tools can help achieve continuous deployment even on smaller projects.

#speakgeek - Angular JS

Derek Chan

Sexy React Stack

KMS Technology

What TDD Can Teach Us About API Design

Jon Phenow

WE are Doing it Wrong - Dmitry Sharkov

QA or the Highway

As companies mature their software development practices, automated acceptance-level testing is becoming more commonplace. In particular, Cucumber and its Gherkin-based equivalents are enjoying widespread use. Through observing and facilitating the adoption and implementation of Cucumber test suites, I have found ways in which the technology has helped teams greatly, but I have also found ways in which it hindered them. I realized that Cucumber and its kin are appropriate tools in fewer situations than the ones in which they are currently employed. In other words, many teams that use such frameworks need to reevaluate whether they are right for the job, and perhaps replace them. I invite all involved in automated acceptance testing to attend as I try to build a compelling case for this notion.

Improving Dashboards with open content sharing

Lachlan Hardy

React & Redux, how to scale?

KMS Technology

Author: Son Tang - Senior Engineer Manager Contact Email: sontang@kms-technology.com Git repo: https://github.com/hunterbmt/react_redux_seminar Working as a Front-end developer is more challenging than ever since the Front-end part of application is no longer simple tasks. Nowadays, with the increased popularity of Single Page Application (SPA), developing a Front-end application requires more tools, more frameworks and also more attention from software engineers to application architecture so as to make sure high performance and scalability. When the complexity of your SPA increases, more people have to work on the application at the same time and a larger number of components and UI elements are built. That results in the application scalability becoming a signification problem. Without a good approach, the more complicated our application becomes, the buggier, the more unproductive and low-performing it becomes. React and Redux are one of many technical stacks which provides a lot of support to developers to build a solid SPA in an easy and effective way. They are easy to pick up and to be productive with. This presention will discuss benefits of using React and Redux as well as how to architect application in order to scale effectively without sacrificing benefits we have from React and Redux.

iOS Scroll Performance

Kyle Sherman

Deploying Straight to Production: A Guide to the Holy Grail - PrDC

damovisa

You’ve toiled hard on your code, tested it locally, and you’re confident it’s ready to go. But how long until you see it in production? For some teams, it can be months or even years. By the time your new feature or bug fix gets used in anger, you’ve forgotten what you did! But with a great deployment pipeline and some clever architecture, there’s a better way. This session is packed with war stories and real world successes. We’ll walk through the realities of a no-touch deployment pipeline that you can trust all the way to production, and we’ll examine some clever architectural patterns to enable true software agility. By the end, you’ll be convinced that if it’s not in production, it doesn’t count. If you struggle to get updates in the hands of users, this is the session for you.

CloudDevelop 2014 - Containerizing Application Development

Avi Cavale

Mobile Testing at Gilt

Gilt Tech Talks

This document summarizes mobile testing practices at Gilt. It describes how Gilt started with an informal mobile testing process when the app was simple, but as features and the codebase grew, more structure was needed. Gilt introduced continuous integration, code conventions, and began writing tests to help scale testing and reduce issues. They chose Appium for mobile test automation since it uses the same Selenium infrastructure they had in place and allows testing on both iOS and Android without needing to compile a separate SDK. Page object modeling and explicit waits were implemented to make tests more reliable and representative of the app's state. While challenges remain around overlays and accessibility, writing tests has helped testing scale and reduced pressure on QA as the mobile business grows.

The Open Web

Lachlan Hardy

The document discusses the open web and provides definitions of key concepts. It describes the open web as stemming from a common philosophical approach of open specifications, having open source reference implementations, and involving public participation in evolution. Web standards like HTML, CSS, and JavaScript that have broad browser support are provided as examples. Open specifications like OpenID, Microformats, and OAuth that work together in a modular way are also discussed. Examples are given of how URLs and APIs can be open and readable. The document advocates for using these open web technologies and standards to make content and data more accessible and to better connect users.

Refactoring page objects The Screenplay Pattern

RiverGlide

The document discusses the Screenplay pattern as an alternative to page object models for structuring automated test code. The Screenplay pattern models tests as interactions between actors performing tasks. This improves test code design by separating responsibilities and following SOLID principles. The pattern models the problem domain rather than the technical solution, focusing test code on key user tasks. This makes test code more maintainable, flexible and resilient to changes than traditional page object approaches.

Ember.js - Harnessing Convention Over Configuration

Tracy Lee

The document appears to be a presentation about Ember and Ember-CLI. It discusses the power of Ember's conventions over configuration approach and the Ember-CLI tool. It highlights features like app structure, Babel compilation, live reload, testing support, and deployment pipelines. The presentation demonstrates how to get started with Ember by installing Ember-CLI and generating a new app, and covers utilizing the addon ecosystem with examples like Ember Data. Resources are provided for learning more about building basic Ember apps.

image_upload Plugin 2007/12/7

Yasuko Ohba

CodeIgniter L4 file upload & image manipulation & language

Mohammad Tahsin Alshalabi

This document discusses Codeigniter's file upload, image manipulation, and language features. It describes how to use the File Upload class to upload files with validation and preferences. The Image class allows resizing, cropping, rotating, and watermarking images. Language files can be created and loaded to retrieve translated text for multi-language applications. Examples are provided for uploading files, resizing images, and loading language files.