Gleb Bahmutov PRO
JavaScript ninja, image processing expert, software quality fanatic
-
How We Introduced Automated Web App Testing in A Large Organization
Many organizations struggle with building a reliable set of automated tests for their React web applications. Yet a set of manual test plans is not an answer; testing without automation is slow, gives low confidence in the software, and the test results provide little actionable feedback to the developers. Should we just write unit and component tests using Jest? You must be joking - these tests are definitely not enough to ensure the app works. In this presentation, I describe how a large company has built a comprehensive automated set of end-to-end and component test suites after two previous unsuccessful attempts. I will show how to build trust between the QA engineers and front-end developers, how to convince other stakeholders that investing time in testing is important, and how to balance the different types of tests: e2e, component, unit, and API to cover both the happy paths and the edge cases. Presented at React-Next 2021.
-
Supercharge Your Cypress Tests With Plugins
Do you like writing End-to-End tests using Cypress? What if I told you that you can unlock the full power of Cypress by ... writing JavaScript code to extend the built-in Test Runner features? Be able to add more testing features, write shorter tests, have more power at your disposal? Most people only scratch the surface of the web application tests, but if you learn how to use the existing plugins (and there are lots of them!) and write your own can take your tests to the next level.
-
Answers to Your Burning Questions About Testing
In the pursuit of building rock-solid end-to-end testing suites, there are many variables that need to be decided in order to maintain a consistent testing environment. If left undefined, these variables can lead to endless wasted cycles spent on the effects, rather than simply eliminating the root cause. Presented at EnterpriseNG Dec 2021
-
How We Introduced Automated Web App Testing in A Large Organization
Many organizations struggle with building a reliable set of automated tests for their web applications. Yet a set of manual test plans is not an answer; testing without automation is slow, gives low confidence in the software, and the test results provide little actionable feedback to the developers. In this presentation, I describe how a large company has built a comprehensive automated set of end-to-end test suites after two previous unsuccessful attempts. I will show how to build trust between the QA engineers and front-end developers, how to convince other stakeholders that investing time in testing is important, and how to balance the different types of tests to cover both the happy paths and the edge cases.
-
Testing Pyramid Makes Little Sense, What We Can Use Instead
The testing pyramid - the canonical shape of tests that defined what types of tests we need to write to make sure the app works - is ... obsolete. In this presentation, Roman Sandler and Gleb Bahmutov argue what the testing shape works better for today's web applications. Presented at TestJSSummit 2021, video at https://portal.gitnation.org/contents/testing-pyramid-makes-little-sense-what-we-can-use-instead
-
Not just a blog, but a knowledge warehouse
This presentation describes my personal journey to "power" blogging. Every time I solve a problem, I describe the solution in a blog post to remind myself the next time I need it how I have done this. Then I describe how I use the Algolia search index to find the blog posts, and how I now scrape the blog posts, the presentation slides, and the YouTube videos too. Presented at Hashnode Open-Source 2021
-
Full End-to-End Testing for Your HTML Email Workflows
Every time a new user registers for your service, your application probably sends a confirmation email.How does that email look in the user's browser? How does it look on a mobile screen? And most importantly: does it work? In this presentation, I will show the full end-to-end open-source testing procedure for validating HTML emails. We will test the email functionality, accessibility, and visual look and style to ensure that our users are not silently dropping out due to a broken email subsystem. Presented at InfobipShift 2021, video at https://youtu.be/igj8OQhY0Jg
-
Integration Testing for React Native Apps
My unpopular opinion is that testing is ... important. How do you test your React Native apps? In this presentation, I will show how to run full integrations tests using Cypress while the RN app is running in the browser. This method can cover most of the application's code and be effective at finding logical errors and mistakes when calling the server APIs. Presented at ReactFinland 2021. Find the video at https://www.youtube.com/watch?v=PIxaFbMBez0
-
Book Quotes
A test deck for practicing scraping slides.
-
The Testing Shapes: Pyramid, Trophy, and Crab
The testing pyramid - the canonical shape of tests that defined what types of tests we need to write to make sure the app works - is ... obsolete. In this presentation, Roman Sandler and Gleb Bahmutov argue what the testing shape works better for today's web applications. Presented at Mercari Dev meetup.
-
End-to-End Testing for a Real-time Chat Web Application
In this presentation, I will show how to write realistic end-to-end Cypress tests for a real-time chat web application implemented using WebSockets. We will see how the test runner can act as a second chat user, and how to truly control two test runners to "talk" to each other during the test. Everyone learning to write tests for the modern web can benefit from this presentation. Presented at QA Global Summit V2
-
Cypress Declassified
Everyone’s talking about Cypress. But they don’t know what they don’t know… Get the inside scoop on Cypress from Distinguished Engineer Gleb Bahmutov. He’ll be joined by Eran Kinsbruner, DevOps Chief Evangelist at Perforce. Together, they’ll dive into how dev teams are testing, learning, and optimizing with one of the fastest-growing front-end automation frameworks. You’ll Learn: - Most advanced features for automating with Cypress. - Best practices for scaling & optimizing with Cypress. - When and how to use Cypress with commercial tools. - What to expect on the roadmap for Cypress.
-
Cypress for Angular Developers
This presentation discusses how Angular developers can take advantage of Cypress Test Runner to write simple and powerful end-to-end tests. We will look at the custom commands, page objects, using fixtures and mocks, dynamic waits, and migrating from Protractor to Cypress.
-
CommitEd: Introduction to Cypress
Introduction to Cypress. This 1-hour presentation gives an introduction to the Cypress Test Runner, its architecture, and the problems it is solving. We will cover end-to-end testing, accessing the application’s internal state, component testing, API testing, visual testing, and collecting code coverage from tests. We will also look at network stubbing and the trade-offs between the full stubbing and spying on the network traffic. The presentation will be followed by questions and answers. Video at https://commited.tech/events/session-introduction-to-cypress/
-
Visual Testing using Cypress
Visual testing is extremely effective at confirming the application works and looks the way it did previously, and that the new commits have not accidentally broken it. In this presentation, I will show how to do visual testing using Cypress test runner, both at the end-to-end and at the individual component levels. We will also consider the trade-offs of doing image diffing ourselves vs paying for a 3rd party service. Video available at https://youtu.be/KX6Xb5oIaH0
-
Testing Web Apps on Every Commit, No Excuses
In this presentation, Gleb will show how every commit and every pull request can run the full set of realistic end-to-end tests, ensuring the web application is going to work for the user. He will look at the modern CI setup, benefits of clean data environments, and parallelization speed-ups. Anyone looking to learn how awesome the modern automated testing pipeline can be would benefit from this presentation. Presented at BrightTALK 2021
-
Using End-to-end Tests as Documentation
Keeping the documentation up-to-date with the web application is hard. The screenshots and the videos showing the user how to perform some task quickly fall out of sync with the latest design and logic changes. In this presentation, I will show how to use end-to-end tests to generate the documentation. By keeping the tests in sync with the application, and by running them on every commit, we will update the documentation, ensuring our users never get confused by the obsolete docs. Presented at TestingStage 2021, video at https://youtu.be/H9VqsTZ9NME
-
TDD: Test-Driven Documentation
If you are working on the web application, and try to document it for the users, what do you do? Do you copy / paste screenshots into the docs? Does your documentation slowly diverge from the application? What if there was a better way? In this talk, I will show how to use the tests to document the web-application behavior, ensuring the docs are always correct. Presented at CityJS 2021
-
slides-dark-mode
This slides.com deck picks different styles depending on the viewer's OS preference. By default, the deck will have a pink-white background. But if you set your OS to Dark mode, the presentation will switch to the dark background and light text.
-
How cy.intercept Works
In this presentation, Gleb Bahmutov explains how the new cy.intercept command works to spy or stub network calls from your web application. He will explain how the intercept works under the hood and how to avoid several common testing problems. Everyone writing Cypress tests would benefit from learning about cy.intercept command and from watching this presentation. Video at https://www.youtube.com/watch?v=LEeoQp1j93I
-
Don’t Make These Testing Mistakes
In this talk, I will discuss the common mistakes developers make when writing Cypress tests and how to avoid them. We will discuss tests that are too short, tests that hardcode data, tests that race against the application, and other mistakes. I believe this presentation will be useful to anyone writing E2E tests using JavaScript. Presented at TestJSSummit in Jan 2021
-
Cypress: Beyond the "Hello World" Test
In this presentation, Gleb Bahmutov, a Distinguished Engineer at Cypress will show how to write realistic Cypress tests beyond a simple "Hello World" test. We will look at Node vs Browser boundary, cy.task, setting up the database state, stubbing browser APIs, documentation, GitHub issues, Cypress Studio, and other advanced topics. Everyone who is just starting with Cypress or is an advanced user will benefit from attending this free meetup. Video at https://www.youtube.com/watch?v=Q5djbLL1Pjg
-
Testing Your Documentation Search
Good documentation with powerful search is the key to the project's success with users. I will show how to configure Algolia search to scrape your site, and how to test the search using Cypress.io test runner. Presented at AngularUp in Nov 2020. Video at https://www.youtube.com/watch?v=cqhV8UbT5LQ
-
End-to-end Testing With Cypress
Unit testing is hard and time-consuming; and worse - the users and the customers do not care! They only want the features working in the production system, everything else is development overhead. If this is the case, how do we improve web application quality? How do we catch the bugs early? How can we test the deployed system effectively? This presentation tries to answer many of these questions in a web framework agnostic way using open source test runner Cypress.io.
-
Find Me If You Can
Having a good text search is the key to successful documentation, especially as the number of pages, examples, code recipes, answers, and other user-facing text snippets grow. In this presentation, I will show how to set up the Algolia search index and use it from a static site to make sure your users find _everything_ they are looking for. Video at https://www.youtube.com/watch?v=z_RutLs0W70
-
SDET
Short greeting to SDET Meetup, where I talk about recent features we have released and our current work. Video at https://www.youtube.com/watch?v=XQ6WQTJ05p0&feature=emb_logo
-
Я вижу что происходит: визуальное тестирование компонентов; I see what is going on
Slides are in English. В этом докладе я расскажу как визуально тестировать веб-приложения бесплатно, то есть даром, как сказал Винни-Пух. Визуальное тестирование дополняет функциональное тестирование и за один "мах" может сравнить целую страницу с "золотым" эталоном. Это очень эффективно заменяет множество индивидуальных тестов, ловит проблемы с CSS, и гарантирует что приложение работает правильно и выглядит не хуже чем было. For QAFest 2020, video at https://youtu.be/3Z-doNgoJFI
-
Visual Testing for React Components
Many modern web frameworks use components as their building blocks. In this talk, I will show component testing using Cypress – and I mean “show” literally. You will see the component running inside a real browser, you will interact with the component like a real user, and you can debug the component using the real browser’s DevTools. Finally, I will go through the current open source and commercial options for visually testing the component’s styles and rendering. Presented at Des Moines JS, video at https://youtu.be/gUFdU5fQs4o
-
I See What is Going On
Visual Testing for Your Components. Many modern web frameworks use components as their building blocks. In this talk, I will show component testing using Cypress - and I mean "show" literally. You will see the component running inside a real browser, you will interact with the component like a real user, and you can debug the component using the real browser's DevTools. Finally, I will go through the current open source and commercial options for visually testing the component's styles and rendering. Read blog post https://glebbahmutov.com/blog/open-source-visual-testing-of-components/ Video at https://www.youtube.com/watch?v=00BNExlJUU8
-
Testing without pain or fear
End-to-end testing with Cypress, presented at TechTrain.ru in June 2020. Video at https://www.youtube.com/watch?v=QRnd4nvR_dc
-
What Going All-Remote Taught Us About Appsec and Testing Shortfalls
The Covid-19 pandemic led to a lot of tech companies converting to remote teams almost overnight, and for some this may even become the norm. So as we adjust to new ways of working, how do you ensure that your appsec procedures are designed to withstand any changes in your team dynamics? Video at https://resources.whitesourcesoftware.com/wistia-webinars/what-going-all-remote-taught-us-about-appsec-and-testing-shortfalls
-
CircleCI Orbs vs GitHub Actions vs Netlify Build Plugins CI Setup
In this meetup discover CircleCI Orbs vs GitHub Actions vs Netlify Build Plugins - what are they and how they simplify continuous integration setup with Gleb Bahmutov. Video at https://www.youtube.com/watch?v=McwE2tztlkA
-
Browser Is The New ... Server
We see the great technology unification, with the boundary between the server and the client (browser) becoming blurrier every day. Who has time and budget to write separate code bases? In this presentation, Gleb will show the ultimate combination of NPM's two most popular packages: Browserify and Express; and their product that allows moving the complete server to run inside the browser's ServiceWorker. It is like server-side rendering but inside your browser, and even runs when JavaScript is disabled! Video at https://www.youtube.com/watch?v=NfZrL5eJa3g
-
Fast and Effective ... End-to-End Tests?!
In this talk I will show how testing could be a way to speed up web application development rather than hinder it. I will show end-to-end testing as it should be: fast, providing quick feedback, and able to simulate hard to recreate edge cases. I will also show types of testing that greatly complement E2E testing: visual testing to prevent style regressions, API testing to test edge cases, accessing native browser objects, and component testing.
-
GitHub Actions in Action - NERDSummit
In this presentation, I will show how simple the continuos integration can be with GitHub Actions. They are powerful, have generous limits for public repositories and can be easily reused. In particular, I will show a few use cases that can be of interest to any JavaScript or TypeScript developer: - How to run Prettier inside a GH Action and push any updated code back to the repository - How to correctly install Node dependencies with a single YAML line - How to run end-to-end Cypress tests without pulling your hair out. Video at https://www.youtube.com/watch?v=zhPqf5z_crc
-
Stop! Don't write another unit test, write a Cypress test!
This presentation looks at the variety of ways we can test a typical web application. From unit tests to end-to-end, from functional to visual testing, from happy paths to the edge cases - there are a lot of solutions available, and each new technique gives us additional confidence in our application. This presentation will teach you how to guide test writing using code coverage using Cypress open-source test runner.
-
JavaScript: from imperative to functional reactive
JavaScript is an interesting language. It can mimic almost any style you want: procedural, object-oriented, functional, etc. In this presentation, I will take a simple problem and will solve it using different approaches. With each step, we will see the power of the new approach to take the complexity away, while still being the JavaScript we all love to hate.
-
Automated Testing with Cypress.io
This talk shows how quick and simple it can be to write end-to-end tests for web applications – if your testing tools are not fighting you all the time. I will go over writing E2E tests using Cypress.io (https://www.cypress.io/), controlling the network during tests, using visual testing and setting up continuous integration to perform E2E tests on each commit.
-
GitHub Actions in Action
In this presentation I will show how simple the continuos integration can be with GitHub Actions. They are powerful, have generous limits for public repositories and can be easily reused
-
Cypress.io – the State of the Art
This talk shows how quick and simple it can be to write end-to-end tests for web applications – if your testing tools are not fighting you all the time. I will go over writing E2E tests using Cypress.io, controlling the network during tests, using visual testing and setting up continuous integration to perform E2E tests on each commit. Video at https://www.youtube.com/watch?v=JL3QKQO80fs
-
Good News About End-to-end Testing with Open Source Cypress.io
Modern day web applications are hard to test. They are dynamic, constantly asking for new data and updating the DOM. They are changing, loading new code as the user browses. They are unpredictable due to network delays and asynchronous UI updates. The existing tools that run outside the browser, sending imperative commands during the test, have hard times keeping up with the apps. Learn how to improve your job performance and reduce stress with Cypress, a less flaky, simpler to understand and debug, open source testing tool with excellent documentation that can be used to write end-to-end tests, run them locally and on CI, and give the entire team confidence that the user will not see a broken application in production.
-
End-to-end testing is fast and easy with Cypress.io
Unit testing is hard and time-consuming; and worse - the users and the customers do not care! They only want the features working in the production system, everything else is development overhead. If this is the case, how do we improve web application quality? How do we catch the bugs early? How can we test the deployed system effectively? This presentation tries to answer many of these questions in a web framework agnostic way using open source test runner Cypress.io.
-
Securing the front end, from a Node server
A simple technique to disable the script injection attacks on your web pages is to disable the inline JavaScript. This means that most popular ways to inject variables and code fragments into your pages will have to change. I will show the JavaScript to JavaScript rendering engine for Express that allows you to set very strict and safe Content-Security-Policy on your website. Not only my approach is much safer, but it will be very testable as well.
-
Journey from procedural to reactive JavaScript with stops - CoderCruise 2019
Understand the differences between imperative, object-oriented, functional, reactive and other styles of programming JavaScript can mimic. Each style brings more power and elegance to your code, and I will show how to adopt the new paradigm without losing your mind in complexity.
-
Self-caused Global Extinction
There is a world beyond simple "console.log" statements. In this talk, I will show the best practices for logging from Node programs. Good logs are essential when trying to understand the real-world behavior of your program, debugging a failure and even during API testing.
-
Log it like you mean it
There is a world beyond simple "console.log" statements. In this talk, I will show the best practices for logging from Node programs. Good logs are essential when trying to understand the real-world behavior of your program, debugging a failure and even during API testing.
-
Visual Testing and Code Coverage
In this talk, I will use code coverage to guide end-to-end tests writing and visual regression testing to avoid style regressions. I will also explain how asynchronous tests can be made to look synchronous. Presented at BostonJS meetup, June 2019
-
Testing Tools and Their Friends
In this talk, I am showing how to pro-actively prevent errors from creeping into production. I will use end-to-end tests, code coverage to guide their writing and visual regression testing to avoid style regressions. Presented at JSNation Amsterdam 2019. Video https://youtu.be/OYUdlXY1joQ
-
Good News about End-to-end Testing
Have you heard: e2e testing is easy! It is easy to get started, it is easy to write complex tests, it is easy to run on CI, it is easy to do visual testing and it is even easy to collect code coverage.
-
Functional End-to-end Tests for RealWorld App
Presentation for Cypress.io + Applitools webinar covering: creating a test user, logging in via API, test shortcuts, clearing the data before tests. Uses the real-world app as an example.
-
Visual Testing With Cypress and Percy
Cypress.io gives you a fast and reliable way to ensure your app is functioning exactly as intended on every commit. Using it with Percy’s visual testing capability provides end-to-end confidence. Join Mike Fotinakis, Co-Founder and CEO of Percy, and Cypress’ VP of Engineering, Gleb Bahmutov, on Wednesday, April 10 at 10 am PDT / 1 pm EDT to learn about the value of using Cypress and Percy, both independently and together, as well as to get an in-depth look at integrating and writing tests for your needs. Video at https://www.youtube.com/watch?v=MXfZeE9RQDw
-
JSON Schemas: State of Testing
JSON schemas is a portable declarative way to describe the shape of an object. In end-to-end testing, we can use these schemas to validate data fixtures, confirm server responses and sanitize data flowing through the application and tests for simpler assertions. In blog post form at https://www.cypress.io/blog/2018/07/10/json-schemas-are-your-true-testing-friend/
-
JSON Schemas are your True Testing Friend - ConFoo
In our company we have a lot of data flowing from the user’s applications (and we are backwards compatible) to the API, then this data is displayed in the web dashboard. How do we avoid accidentally breaking API contracts, while adding new features? We have started using json-schema convention and wrote a few tools around it to lock down our API protocols. Now we have full confidence in our tests, and major refactoring and releases happen without hiccups. Bonus: our tests are realistic, elegant and easy to understand. Presented at Confoo.CA 2019.
-
Dynamic Presentation Example
Example of a presentation where the speaker can pick where to "jump" from a slide using linked elements
-
It's not your parents' HTTP - Confoo.CA
The Internet of simple textual requests and responses is done. Finished. Obsolete. The modern web is a web of binary, persistent connections like WebSockets, WebRTC, HTTP/2 and QUIC. Today's Internet is a strange place where things are received before they are requested (Server Push) and a web application work without the Web (offline support with Service Worker). This presentation is going to be your map to this new terrain.
-
Building Web Apps with Hyperapp - NERD Summit 2019
What is the smallest and purest front-end framework out there? Did someone say Elm? I said smallest! The answer is Hyperapp - a really tiny, Elm-inspired pure functional web framework that combines the best features of today's hottest frameworks. It has built-in state management, pure functions, virtual DOM and still is easy to learn in a few minutes. Come to this session to learn how Hyperapp allows one to build a complete web application from small pure parts that are easy to code, simple to understand and convenient to test. NERD Summit 2019 video https://www.youtube.com/watch?v=8pcx0XitUCc
-
Cypress: testing without Selenium Part 2
* Cypress architecture * Declarative test syntax * Code coverage updates * CircleCI Orbs * Component and API testing. SeleniumCamp 2019 Kyiv, Ukraine Video at https://www.youtube.com/watch?v=AYlFF_KTFl8
-
Cypress: testing without Selenium Part 1
Part 1. Modern web application testing is a hard and ungrateful job. But maybe this is just because we still don’t have a great tool for testing, that could be our friend not enemy? In this talk, I will present you Cypress.io – free test runner made without Selenium or WebDriver. With Cypress you could make your tests quick, simple and useful. Presented at SeleniumCamp in Ukraine, video at https://www.youtube.com/watch?v=hk4qtXgL12k
-
TypeScript checks without TypeScript
In this presentation, I will show how to get type checks without going all the way to TypeScript. We will look at how you can write JSDoc comments to describe types. I will also show how we provide external TypeScript definitions in Cypress end-to-end tests where the tests themselves are written in JavaScript.
-
Stop using Page Objects and Start using App Actions
Writing maintainable end-to-end tests is challenging. Often testers create another layer of indirection on top of the web page called page objects to execute common actions. In this presentation, I argue that page objects are a bad practice, and suggest dispatching actions directly to the application’s internal logic. This works great with a modern test runner like Cypress.io that runs the test code directly alongside the application’s code inside the browser.
-
Test Coverage Update: State of Testing
Code coverage is useful to make sure every line of code with unit tests. But it has a few shortcomings and is mostly useless for end-to-end tests. What else can we do to target out end-to-end tests? In this presentation, I will touch on element coverage that seems to be useful when covering web application tests. In blog post form at https://www.cypress.io/blog/2018/12/20/element-coverage/
-
Page Objects in Cypress: My opinion
Page Objects vs functions vs custom commands in writing Cypress end-to-end tests. Work in progress. Read full blog post at https://www.cypress.io/blog/2019/01/03/stop-using-page-objects-and-start-using-app-actions/
-
Cypress Test Runner: SF JS Meetup
Testing is hard. End-to-end testing is really hard. But have you ever wondered if maybe our tools are the ones to blame? What if we could completely rethink testing tools to be fast, useful and effective? Let me show you how to quickly test any web application using Cypress.io - a modern open source test runner designed to make you more productive. Don't believe the hype? Come see a Cypress demo for yourself and prepare to be amazed.
-
CircleCI + Cypress.io: End to end testing made easy
Cypress makes setting up, writing, running and debugging tests for web applications easy with their all-in-one testing framework, assertion library, with mocking and stubbing. With the newly released CircleCI Orbs feature, you can quickly set up Cypress on CircleCI to run all of your tests on a single machine or on several machines in parallel to cut down the testing time. Video at https://www.youtube.com/watch?time_continue=59&v=J-xbNtKgXfY
-
Well Tested Software
Testing is hard. Realistic testing of web applications in a real browser is even harder. In this presentation, I will show you how to quickly test any web application using cutting-edge tools. Then we will see how to build high-quality software from individual modules using appropriate tools and creating an environment where bugs can be discovered immediately and fixed quickly. This session will give tremendous value for anyone programming in JavaScript or building modern web applications. Øredev 2018 Video at https://vimeo.com/311931793
-
Hyped About Hyperapp - Øredev 2018
What is the smallest and purest front-end framework out there? Did someone say Elm? I said smallest! The answer is Hyperapp - a really tiny, Elm-inspired pure functional web framework that combines the best features of today's hottest frameworks. It has built-in state management, pure functions, virtual DOM and still is easy to learn in a few minutes. Come to this session to learn how Hyperapp allows one to build a complete web application from small pure parts that are easy to code, simple to understand and convenient to test. Øredev 2018 Video at https://vimeo.com/302036840
-
End-to-end Testing with Cypress
Testing is hard. End-to-end testing is really hard. But have you ever wondered if maybe our tools are the ones to blame? What if we could completely rethink testing tools to be fast, useful and effective? Let me show you how to quickly test any web application using Cypress.io - a modern open source test runner designed to make you more productive. Don't believe the hype? Come see a Cypress demo for yourself and prepare to be amazed.
-
Cypress Test Parallelization and Grouping
Intro to end-to-end test parallelization and grouping with Cypress Dashboard service. Part of Cypress webinar on October 16 2018. Video at https://www.youtube.com/watch?v=FfqD1ExUGlw
-
End-to-end testing is hard - but it doesn't have to be
Cypress.io is an open source free end-to-end test runner that runs your web application inside an iframe in a browser it can closely control. This architecture completely changes how your tests behave (hint: no flake), what you can test (pretty much everything), and why you write more e2e tests (because you love writing them). In this talk, I will give a very brief intro to Cypress itself but mostly will concentrate on how it changes the entire testing experience. Cypress users can test web applications by observing just the external behavior (DOM, network calls, storage) or can reach deep inside the application's code, and I will explain the trade-offs. Finally, I will discuss why Cypress tests do not use "async / await" keywords, and instead look like declarative reactive streams. Video https://www.youtube.com/watch?v=swpz0H0u13k from ReactiveConf 2018
-
Cypress Intro
A quick introduction to Cypress.io end-to-end test runner. - install - basic GUI tests - headless run - network control and fixtures - mocking JS methods
-
End-vue-End Testing
Testing Vue applications can be quick and painless. In this presentation, I will show how to test small parts of Vue apps using vue-test-utils, and how to move "up" the testing pyramid to component and end-to-end tests using Cypress. Presented at VueNYC meetup in Sept 2018. Video at https://www.youtube.com/watch?v=uowaTHQDcKc
-
Semantic Release
Manually releasing new software versions is dangerous. You might forget to test it before releasing, or you might release a platform-specific version, instead of a general one. Moving the release to the CI and automating it is the key to the repeatable and robust release process. In this talk, I will show how to set up a completely automated yet robust release system with semantic versioning for JavaScript using NodeJS. Presented at VermontCodeCamp 2018.
-
JSON Schemas are your True Testing Friend
In our company we have a lot of data flowing from the user’s applications (and we are backwards compatible) to the API, then this data is displayed in the web dashboard. How do we avoid accidentally breaking API contracts, while adding new features? We have started using json-schema convention and wrote a few tools around it to lock down our API protocols. Now we have full confidence in our tests, and major refactoring and releases happen without hiccups. Bonus: our tests are realistic, elegant and easy to understand. Presented at Boston JS meetup.
-
Painless Testing for Modern Web Applications with Cypress.io
This presentation showcases Cypress.io - an open source, MIT-licensed end-to-end test runner that radically breaks with existing technologies (like Selenium, WebDriver) to be able to test _modern_ web applications. The main focus of Cypress is to give every developer a tool that helps rather than hinders the development process. Thus it has such features as GUI with time traveling debugger and DOM snapshots; headless run mode on CI with video recording by default; full browser DevTools to inspect the application's behavior; spying and stubbing of network calls; and many other advantages compared to existing solutions. Presented at Ministry of Testing Rio de Janeiro.
-
Cypress at ngBoston
Testing is hard. End-to-end testing is really hard. But maybe it is hard because our tools are not up to the task. What if we could redesign the testing experience from the ground up to be fast, useful and effective? In this presentation, I will show Cypress - an open source end-to-end test runner designed from scratch to be useful to developers. Come to learn how testing can be ... a pleasure. AngularBoston 2018, video at https://youtu.be/wQfS3mCDVO0
-
Everything I know about writing quality software
In this presentation I will show all the tools I use to write software that does not break but keeps the users happy. Static types, exception monitoring, unit tests with snapshots, randomized testing, code and data coverage, code complexity metrics and awesome end to end testing tools - the list is long and keeps on growing! The techniques I plan to show are applicable to every framework and environment. Presented at BuzzJS 2018, video at https://youtu.be/1PMxLTfh6lo?t=1
-
Cypress at AngularNYC
Testing is hard. End to end testing is really hard. But maybe it is hard because our tools are not up to the task. What if we could redesign the testing experience from the ground up to be fast, useful and effective? Presented at AngularNYC meetup in May 2018, video at https://www.youtube.com/watch?v=wApmbgPGmqQ
-
Cypress at ReactNYC
Testing is hard. End to end testing is really hard. But maybe it is hard because our tools are not up to the task. What if we could redesign the testing experience from the ground up to be fast, useful and effective? Presented at ReactNYC meetup in May 2018
-
End to End Testing in the Future
Unit testing is hard and time consuming; and worse - the users and the customers do not care! They only want the features working in the production system, everything else is development overhead. If this is the case, how do we improve the web application quality? How do we catch the bugs early? How can we test the deployed system effectively? And finally, how do we get rid of Selenium? This presentation tries to answer many of these questions in a web framework agnostic way. Presented at WeAreDevs Congress 2018, video at https://www.youtube.com/watch?v=p38bIMC-YOU
-
Hyped about Hyperapp
What is the smallest and purest front end framework out there? Did someone say Elm? I said smallest! The answer is Hyperapp - a really tiny, Elm-inspired pure functional web framework that combines the best features of today's hottest frameworks. It has built-in state management, pure functions, virtual DOM and still is easy to learn in 30 minutes. Presented at Boston Code Camp in April 2018 and BostonJS meetup
-
Painless Testing for React Applications
Testing is hard. End to end testing is really hard. But maybe it is hard because our tools are not up to task. What if we could redesign the testing experience from the ground up to be fast, useful and effective? Let me show you how to quickly test a React application using Cypress.io - an open source modern test runner that replaces Selenium. Don't believe the hype - come see Cypress demo for yourself, and I guarantee you will start writing tests. Presented at ReactJS Boston meetup April 2018. Video at https://www.youtube.com/watch?v=lgurVvQsOTY
-
Modern JavaScript - NERDSummit 2018
Let us look at JavaScript - the language that runs the Internet. We will learn how new features are added to the language, how the modern syntax looks, and the main tools for testing, transpiling and bundling JavaScript applications. Anyone looking to start with JS or upgrade development skills will benefit from this presentation. Presented at NERD summit 2018.
-
It's not your parents' HTTP - NERD Summit
I will start with the history of HTTP, and how it changes from 0.9 to 1.0 and to 1.1. I will explain the performance benefit of HTTP/2, the state of support and a very interesting performance feature (Server Push). Then I will talk about real time systems that use Web Sockets for persistent data connection. Then I will talk about data synchronization solutions via in-browser database that can sync automatically. I will talk about offline support and instant web applications using ServiceWorker, and finally I will describe why HTTP/2 is going to be replaced by a protocol named QUIC based on UDP. Presented at NERDSummit 2018
-
Workers of the World, Unite!
WebWorkers have been very useful for performing computation-intensive tasks in parallel, preventing browser lockup. Recently a new beast has appeared: the ServiceWorker. I will show how to use both WebWorkers and a ServiceWorker to add new features to the web development: rendering HTML from data without blocking the main thread, supporting offline mode, computation-intensive tasks. ConFoo 2018
-
Testing Vue
Testing Vue web application using Cypress. End to end testing and integration testing of components. Presented at Vue.js Boston meetup on the last day of February 2018.
-
A Simple Node Checklist to Follow
Checklists have been known to reduce errors during air flights and surgeries. Why don't we use one for our JavaScript projects? I want my NPM module to be useful, robust, and well-documented. Here is my recipe for a module that everyone can rely on: a simple checklist. Rather than forcing everyone to do the same, the checklist only reminds me to do unit testing, publish smaller module, have good API examples, and lots of other useful things. ConFoo 2018
-
The Shape Of Testing Pyramid
Presentation for AssertJS 2018: testing pyramid, the difference in unit tests vs integration tests, using end to end testing tool to run unit tests for components, various types of diffing: snapshot testing, screenshot diffing, application behavior diffing. Video at https://www.youtube.com/watch?v=5FnalKRjpZk
-
Think Inside The Box
It used to be hard to actually run code in production. I needed to rent a rack server from a company, login into the machine, set it up, then periodically deploy new application version. Deploying often meant overriding the existing running application, taking a server offline. Long, cumbersome, and error prone. No wonder we did deploys once a month! Luckily there are 4 things that recently revolutionized the way I deploy and run code: Docker, Dokku, Kubernetes and Zeit Now.
-
Modern JavaScript
Let us look at JavaScript - the language that runs the Internet. We will learn how new features are added to the language, how the modern syntax looks, and the main tools for testing, transpiling and bundling JavaScript applications. Anyone looking to start with JS or upgrade development skills will benefit from this presentation. Presented at Boston Code Camp 2017.
-
The Future Belongs to You and Your JavaScript
Overview of modern JavaScript language and most commonly used tools. Browsers, servers, desktop and every place in between where JS can run. Code snippets and ServiceWorkers. Presented at Øredev 2017
-
Practical Universal Apps in Functional JavaScript
Writing solid code is hard. Writing portable code that can run on the server and in the browser is harder. Writing readable code that is easy to modify and extend might be impossible. Let us try achieve all three goals by writing JavaScript in functional style. JS is no Haskell, but can mimic a traditional functional language pretty well, as I will show in this presentation. Plus everything in the world can run JavaScript, so FP in JS knowledge applies very widely. Presented at Øredev 2017 video at https://vimeo.com/242030169
-
Modern Integration Testing for JavaScript Applications
Unit testing is hard and time consuming; and worse - the users and the customers do not care! They only want the features working in the production system, everything else is development overhead. If this is the case, how do we improve the web application quality? How do we catch the bugs early? How can we test the deployed system effectively? And finally, how do we get rid of Selenium? This presentation tries to answer many of these questions in a web framework agnostic way. BostonJS meetup. Video at https://www.youtube.com/watch?v=D20nX2zAypk
-
Snapshot Testing
Snapshot Testing is a recent technique in unit testing and automated testing in general that's been gaining some traction, thanks to a new excellent test runner called Jest. Gleb Bahmutov from Cypress.io will explain to us what snapshot testing is, and how to use his family of NPM modules snap-shot-* to go beyond static data. Presented at Atlanta JS Meetup, video at https://www.youtube.com/watch?v=MAKRJJ06Nw4
-
Effective E2E Testing with Cypress
The testing pyramid is a bad bad practice; it puts focus on unit tests, while your users really care about an end to end quality. For web developers, we are open sourcing a very powerful E2E tool called Cypress that is capable of giving your confidence that the app is going to work. Presented at AngularDevSummit 2017
-
Hello HTTP!
Let's walk through the history of HTTP, its original design goals and how they shape the modern Internet. We will look at the current standard, and what is coming tomorrow. We will also learn and refresh a whole bunch of acronyms: TCP, HTTP, RFC, IETF, UPD, QUIC. Every developer working or even using WWW will benefit from this presentation.
-
Shapes of Development
A geometric shape is simple to remember and visualize concept, familiar to any child. In software development we have a few concepts with associated shapes: agile is shown as a spiral curve, waterfall as, well, a waterfall, etc. In this presentation I will show the shapes that describe other modern development approaches and architectural styles.
-
Shhh, don't tell anyone but you are using HTTP/2!
I will walk through the history of HTTP, its original design goals and how they shape the modern Internet. We will look at at the current standard, and what is coming tomorrow. Through the presentation I will point at some security issues already found with HTTP/2 and its implementation.
-
It's not your parents' HTTP
The Internet of simple textual requests and responses is done. Finished. Obsolete. The modern web is a web of binary, persistent connections like WebSockets, WebRTC and HTTP/2. Presented at NDC Oslo 2017, video at https://www.youtube.com/watch?v=BhTbOtuSUzQ
-
Pure Magic: Functional Reactive Web Applications in 2017 and Beyond
There are a few web frameworks that are all the rage right now: React, VueJs, but which frameworks are functional AND reactive? Dr. Gleb Bahmutov will talk about functional reactive web applications you can write today, and why they are going to rock tomorrow. Presented at Maine.JS meetup in May of 2017
-
Web app quality beyond testing - CycleConf 2017
What makes a framework great? How do you have others give it a try? How do you make sure the web application runs correctly? What is a brass ball valve? Video at https://vimeo.com/album/4578937/video/216829554
-
Self-improving software - NodeWeek
Every JavaScript project requires 3rd party modules. As soon as you depend on specific versions, your module falls behind. I will show how to keep your software up to date without any effort (as long as there are some tests). Everything will be automated and reliable; it is like bringing an army of robots to help you.
-
Self-improving software - ConFoo CA 2017
Every JavaScript project requires 3rd party modules. As soon as you depend on specific versions, your module falls behind. I will show how to keep your software up to date without any effort (as long as there are some tests). Everything will be automated and reliable; it is like bringing an army of robots to help you.
-
Remove the boilerplate - ConFoo CA 2017
In this talk I will show how to remove lots and lots of unnecessary code from your application. Counter variables, wrapper functions, callbacks - they can all be removed using utility libraries or even built-in JavaScript ES5 language features. In each instance there will be a lot less code, but it will be more robust, manageable and simpler to reason about and test. Presented at ConFoo.CA in March 2017
-
Snapshot Testing the Hard Way
Testing is hard and does not pay. Snapshot testing is a way to increase the efficiency of your unit tests while removing a lot of boilerplate code. Recently Jest and Ava testing framework added this feature. I have written a framework-agnostic snapshot testing library and would like to share techniques and design decisions that went into this library.
-
Writing Software That Works
How to write software that works now and will keep working in the future. Plus career advice! Presented as a guest lecture at MIT 6.148 class, January 20th 2017. Developer value, JavaScript modules, semver, linting, unit testing, e2e testing. Video at https://www.youtube.com/watch?v=MHNB6CGENKo
-
Browser is the new server - NodeFest Tokyo
The line between the server and the modern browser is blurry. Transpiling code, rendering static markup, smart caching were traditionally done on the server. These features made the jump to the browser by using ServiceWorkers.
-
Browser is the new server - NodeConf EU
The line between the server and the modern browser is blurry. Transpiling code, rendering static markup, smart caching were traditionally done on the server. These features made the jump to the browser by using ServiceWorkers. Video at https://www.youtube.com/watch?v=5zOaN_FYXwk
-
Secure your Angular Applications
What do Chrome extensions written in Angular and secure websites have in common? They take Content Security Policy seriously! In this presentation I will show how to secure your web application against cross-site scripting attacks and insecure 3rd party code.
-
Fun* JavaScript Workshop
The principles and basics of functional programming in JavaScript using small coding problems. Pure functions, partial application, composition, iteration, lexical scope, Ramda library.
-
Cycle.js: Get in the Loop
Cycle.js - functional reactive framework for pure web apps. Presented at FrontEndCamp at United Nations NYC July 2016. Links and additional resources at https://glebbahmutov.com/blog/cyclejs-frontendcamp/
-
Which JavaScript framework should I use next? - BuzzJS NYC 2016
Should I learn and use Angular 1, React, Angular 2, Ember or something else? What are the common features they all share? How are they different? Are there "better" frameworks that will be popular next year? I will show a couple of new approaches that should be part of any future-proof framework: reactive streams for managing the data flow, virtual DOM abstractions for speed, testability and performance tools built right into the framework. The presentation might be controversial, but the struggle to pick "the next best thing" is very real. Video at https://www.youtube.com/watch?v=ji8hqDi2BnA
-
From procedural to reactive JavaScript with stops - O'Reilly OSCON
How do we convince / train developers used to imperative programming style to switch to functional or even reactive programming? I show the same example implemented in multiple styles to highlight the advantages one would get by going from imperative to object-oriented, functional, lazy evaluation, promise-based, event emitters, and finally reactive approach. The short examples are in JavaScript - the most widely used functional language today.
-
MVC to FRP
Transition from the traditional Model-View-Controller application to Functional-Reactive-Programming. Presented at CycleConf 2016. Video at https://www.youtube.com/watch?v=-PCq4pXaDZw and all links are in blog post https://glebbahmutov.com/blog/cycle-conf/
-
Secure the front end from Node server - Boston Code Camp 25
This presentation will show how to lock down the front end JavaScript code using Content-Security-Policy. I will also show how to prevent sensitive files from being committed to your repos or NPM registry. Presented at Boston Code Camp 25 on April 2nd 2016.
-
Remove the boilerplate - Boston Code Camp 25
How to remove unnecessary code from your code, including asynchronous code and unit tests. Presented at Boston Code Camp 25 on April 2nd 2016
-
Workers of the world, unite!
ServiceWorkers for faster web application boot up. Instant web applications, self-rewriting apps, profiling, ES2015 and modern browsers. Presented at the Web Performance NYC meetup. Video https://youtu.be/4axZ3D75Llg
-
Remove the boilerplate - NationJS
How to remove unnecessary code from your code, including asynchronous code and unit tests. Presented at NationJS Node day 2016 in Washington DC.
-
Unit testing AngularJS - ConFoo.ca
Testing Angular code requires too much boilerplate. In this presentation I will show ng-describe - a BDD helper that removes all extra code and allows to start unit testing in seconds.
-
NodeJS for secure websites
This presentation will show how to lock down the front end JavaScript code using Content-Security-Policy. I will also show how to prevent sensitive files from being committed to your repos or NPM registry
-
Journey from imperative to reactive JavaScript with stops - Boston Code Camp 24
How do we convince / train developers used to imperative programming style to switch to functional or even reactive programming? I show the same example implemented in multiple styles to highlight the advantages one would get by going from imperative to object-oriented, functional, lazy evaluation, promise-based, event emitters, and finally reactive approach. The short examples are in JavaScript - the most widely used functional language today.
-
Explain with examples, without writing any
Humans learn best by example; good technical docs use lots of them. Yet all modern documentation tools (think jsdoc) making writing correct examples and maintaining them a chore. There is no tool support for syntax highlighting, or even guarantee that an example is correct or up to date. On the other hand, solid software projects have lots of well tested, up to date examples. We call them unit tests! In this presentation I will show how to take the unit tests and transform into syntax-agnostic human-friendly examples to be plugged into your docs.
-
Обзор будущих технологий тестирования / Testing technologies of the future
В этом докладе я покажу самые последнии идеи для достижения надежного программного обеспечения для веб: от data-coverage (вместо code-coverage) до тестирования недоступого кода (например, внутри private JavaScript closures), от минимизации boilerplate до тестирования веб-приложений без помощи браузеров; эти решения помогут быстро и дешево достичь высокого уровня качества.
-
Turn the performance knob to 11
Once your Angular application has the features you need, the next step is usually focused on improving its performance, such as the initial load time and responsiveness to user’s commands. The application has to execute quickly in order to be useful. Is the Angular framework fast or slow? I argue that it is very fast, but requires you to know how to measure and optimize the right bottlenecks.
-
Remove the boilerplate
How to remove unnecessary code from your code, including asynchronous code and unit tests. Presented at NodeJS Italy in 2015
-
MIT Career Fair
A presentation for prospective candidate who are interested in joining Kensho. What we do, how we do it, why someone should join us, and how to ace our interview.
-
Unit testing AngularJS - Angular Remote Conf
Testing Angular code requires too much boilerplate. In this presentation I will show ng-describe - a BDD helper that removes all extra code and allows to start unit testing in seconds. Then I will show ng-dice - a combination of dependency injection and code extraction for testing Angular taking advantage of Node require hooks.
-
Effective public speaking
A few tips for organizing and delivering an effective presentation by carefully preparing the content
-
Bend the JS rules in Angular application
Bend the JavaScript rules for powerful Angular applications: access the controller logic from the browser console, mock on the fly, load app from Node, unit test private functions. Presented at ManhattanJS meetup.
-
Unit testing AngularJS
Testing Angular code requires too much boilerplate. In this presentation I will show ng-describe - a BDD helper that removes all extra code and allows to start unit testing in seconds. Presented at AngularNYC meetup in November 2015, video at https://www.youtube.com/watch?v=9DMuLsWzqwg
-
Self-improving software FrontEnd Camp
Any JavaScript project requires 3rd party modules. As soon as you depend on specific versions, your module falls behind. I will show how to keep your software up to date without any effort (as long as there are some tests). You can automatically upgrade dependencies for an individual project, a collection of projects. You can even see the anonymous version upgrade results across the public projects around the world to judge if a particular update is likely to succeed. What about projects that depend on your software? Before releasing a new version, you can test some or all of your dependencies against the new code.
-
Journey from procedural to reactive JavaScript with stops - FrontEnd Camp
How do we convince / train developers used to imperative programming style to switch to functional or even reactive programming? I show the same example implemented in multiple styles to highlight the advantages one would get by going from imperative to object-oriented, functional, lazy evaluation, promise-based, event emitters, and finally reactive approach. The short examples are in JavaScript - the most widely used functional language today.
-
Self-improving software NYC NodeJS meetup
Any JavaScript project requires 3rd party modules. As soon as you depend on specific versions, your module falls behind. I will show how to keep your software up to date without any effort (as long as there are some tests). You can automatically upgrade dependencies for an individual project, a collection of projects. You can even see the anonymous version upgrade results across the public projects around the world to judge if a particular update is likely to succeed. What about projects that depend on your software? Before releasing a new version, you can test some or all of your dependencies against the new code.
-
web application profiling using code snippets
Chrome DevTools code snippets became my favorite tool when investigating performance bottlenecks in web applications. A JavaScript fragment can be stored as a named snippet in the "Sources" DevTools panel and executed in the current page's context, just as if it were a code executed in the browser's console.
-
Self-improving software
Any JavaScript project requires 3rd party modules. As soon as you depend on specific versions, your module falls behind. I will show how to keep your software up to date without any effort (as long as there are some tests). You can automatically upgrade dependencies for an individual project, a collection of projects. You can even see the anonymous version upgrade results across the public projects around the world to judge if a particular update is likely to succeed. What about projects that depend on your software? Before releasing a new version, you can test some or all of your dependencies against the new code.
-
An orchestra of rockstars
Hiring, training and graduation approaches that work for us at Kensho (data analysis and machine intelligence company in Boston and NYC)
-
Journey from procedural to reactive JavaScript with stops - ScotlandJS
How do we convince / train developers used to imperative programming style to switch to functional or even reactive programming? I show the same example implemented in multiple styles to highlight the advantages one would get by going from imperative to object-oriented, functional, lazy evaluation, promise-based, event emitters, and finally reactive approach. The short examples are in JavaScript - the most widely used functional language today.
-
Run digest cycle in web worker
An experiment in offloading the Angular dirty checking and model update step to a separate browser thread. ng-conf 2015, Salt Lake City, Utah. Video at http://youtu.be/lceLw8ROUP8?list=PLOETEcp3DkCoNnlhE-7fovYvqwVPrRiY7
-
Journey from procedural to reactive JavaScript with stops - MountainWest JS 2015
How do we convince / train developers used to imperative programming style to switch to functional or even reactive programming? I show the same example implemented in multiple styles to highlight the advantages one would get by going from imperative to object-oriented, functional, lazy evaluation, promise-based, event emitters, and finally reactive approach. The short examples are in JavaScript - the most widely used functional language today.
-
Journey from procedural to reactive JavaScript with stops
How do we convince / train developers used to imperative programming style to switch to functional or even reactive programming? I show the same example implemented in multiple styles to highlight the advantages one would get by going from imperative to object-oriented, functional, lazy evaluation, promise-based, event emitters, and finally reactive approach. The short examples are in JavaScript - the most widely used functional language today.
-
Performance Profiling Using Chrome Code Snippets
Chrome DevTools code snippets became my favorite tool when investigating performance bottlenecks in web applications. A JavaScript fragment can be stored as a named snippet in the "Sources" DevTools panel and executed in the current page's context, just as if it were a code executed in the browser's console.
-
AngularJs Performance
profiling and improving AngularJs application performance using code snippets, working in batches, offloading work, on-demand computation, memory preallocation and smart DOM updates.