By Katerina Barone-Adesi.
Discover property-based testing, and see how it works on a real project, the pflua compiler.
How do you find a lot of non-obvious bugs in an afternoon? Write a property that should always be true (like "this code should have the same result before and after it's optimized"), generate random valid expressions, and study the counter-examples!
Property-based testing is a powerful technique for finding bugs quickly. It can partly replace unit tests, leading to a more flexible test suite that generates more cases and finds more bugs in less time.
It's really quick and easy to get started with property-based testing. You can use existing tools like QuickCheck, or write your own: Andy Windo and I wrote pflua-quickcheck and found a half-dozen bugs with it in one afternoon, using pure Lua and no external libraries.
In this talk, I will introduce property-based testing, demonstrate a tool for using it in Lua - and how to write your own property-based testing tool from scratch, and explain how simple properties found bugs in pflua.
(c) 2015 FOSDEM VZW
CC BY 2.0 BE
https://archive.fosdem.org/2015/
ARB_gl_spirv implementation in Mesa: status update (XDC 2018)Igalia
By Alejandro Piñeiro.
Since OpenGL 2.0, released more than 10 years ago, OpenGL has been using OpenGL Shading Language (GLSL) as a shading language. When Khronos published the first release of Vulkan, almost 2 years ago, shaders used a binary format, called SPIR-V, originally developed for use with OpenCL.
That means that the two major public 3D graphics API were using different shading languages, making porting from one to the other more complicated. Since then there were efforts to allow making this easier.
On July 2016, the extension ARB_gl_spirv was approved by Khronos, that allows a SPIR-V module to be specified as containing a programmable shader stage, rather than using GLSL, whatever the source language was used to create the SPIR-V module. This extension is now part of OpenGL 4.6 core, making it mandatory for any driver that wants to support this version.
The implementation of this extension for the Mesa driver, focused on the i965 intel driver, was started at the end of 2017. A first talk about the status of such implementation was done this year on FOSDEM. This talk on XDC would present all the updates, and in general it will explain the extension, what advantages provides, how is being implemented for the Mesa driver, and how much is pending to get it enabled.
X.Org Developer's Conference (XDC) 2018
26th, 27th and 28th of September
A Coruña, Spain
https://www.x.org/wiki/Events/XDC2018/
Unit testing and test-driven development are practices that makes it easy and efficient to create well-structured and well-working code. However, many software projects didn't create unit tests from the beginning.
In this presentation I will show a test automation strategy that works well for legacy code, and how to implement such a strategy on a project. The strategy focuses on characterization tests and refactoring, and the slides contain a detailed example of how to carry through a major refactoring in many tiny steps
ARB_gl_spirv implementation in Mesa: status update (XDC 2018)Igalia
By Alejandro Piñeiro.
Since OpenGL 2.0, released more than 10 years ago, OpenGL has been using OpenGL Shading Language (GLSL) as a shading language. When Khronos published the first release of Vulkan, almost 2 years ago, shaders used a binary format, called SPIR-V, originally developed for use with OpenCL.
That means that the two major public 3D graphics API were using different shading languages, making porting from one to the other more complicated. Since then there were efforts to allow making this easier.
On July 2016, the extension ARB_gl_spirv was approved by Khronos, that allows a SPIR-V module to be specified as containing a programmable shader stage, rather than using GLSL, whatever the source language was used to create the SPIR-V module. This extension is now part of OpenGL 4.6 core, making it mandatory for any driver that wants to support this version.
The implementation of this extension for the Mesa driver, focused on the i965 intel driver, was started at the end of 2017. A first talk about the status of such implementation was done this year on FOSDEM. This talk on XDC would present all the updates, and in general it will explain the extension, what advantages provides, how is being implemented for the Mesa driver, and how much is pending to get it enabled.
X.Org Developer's Conference (XDC) 2018
26th, 27th and 28th of September
A Coruña, Spain
https://www.x.org/wiki/Events/XDC2018/
Unit testing and test-driven development are practices that makes it easy and efficient to create well-structured and well-working code. However, many software projects didn't create unit tests from the beginning.
In this presentation I will show a test automation strategy that works well for legacy code, and how to implement such a strategy on a project. The strategy focuses on characterization tests and refactoring, and the slides contain a detailed example of how to carry through a major refactoring in many tiny steps
Brief introduction to Test Automation Frameworks, Acceptance Testing and ATTD using Testerone – custom made solution based on RobotFramework and it’s extensive libraries for Selenium’s and AutoIT’s support.
Bring the test cases closer to business people, leave the technical stuff to technical staff using simple business-to-tech excel sheet (map) for collaboration. Complete the solution by controlling everything using Jenkins CI server.
Refactoring legacy code driven by tests - ENGLuca Minudel
re you working on code poorly designed or on legacy code that’s hard to test? And you cannot refactor it because there are no tests?
During this Coding Dojo you’ll be assigned a coding challenge in Java, C#, Ruby, JavaScript or Python. You will face the challenge of improving the design and refactoring existing code in order to make it testable and to write unit tests.
We will discuss SOLID principles, the relation between design and TDD, and how this applies to your solution.
Reading list:
Growing Object-Oriented Software, Guided by Tests; Steve Freeman, Nat Pryce
Test Driven Development: By Example; Kent Beck
Working Effectively with Legacy; Michael Feathers
Agile Software Development, Principles, Patterns, and Practices; Robert C. Martin (C++, Java)
Agile Principles, Patterns, and Practices in C#; Robert C. Martin (C#)
- Highlight the performance benefits of using Java 8 - after all, you’ll probably have to persuade "The Management" that tampering with
existing code is worthwhile
- Demonstrate how to identify areas of code that can be updated to use Java 8 features, and how to pick which changes will give you the
most benefit
- Demonstrate how to automatically refactor your code to make use of features like lambdas and streams
- Cover some of the pros and cons of using the new features - including suggestions of when refactoring may NOT be the best idea.
Robot Framework is a generic keyword-driven test automation framework for acceptance level testing and acceptance test-driven development (ATDD). It has an easy-to-use tabular syntax for creating test cases and its testing capabilities can be extended by test libraries implemented either with Python or Java. Users can also create new keywords from existing ones using the same simple syntax that is used for creating test cases.
Old presentation was updated on 1st of September, 2014. Content stayed mostly the same but examples were enhanced. Copyrights and some links were also updated a bit later. The presentation is nowadays hosted on GitHub where you can find the original in ODP format: https://github.com/robotframework/IntroSlides
Practical tips for dealing with projects involving legacy code. Covers investigating past projects, static analysis of existing code, and methods for changing legacy code.
Presented at PHP Benelux '10
Pairing WebKit and Wayland for Linux-Based Embedded Web Content Presentation ...Igalia
By Žan Doberšek.
WebKit and its multi-process architecture might not seem suitable for embedded systems at first, but Wayland, the next-gen display system, has already proven itself by running efficiently on TVs, smartphones and single-board computers. This talk will present the techniques that were used to achieve efficient, hardware-accelerated rendering of Web content across the multiple processes of WebKit running under Wayland. Žan Doberšek will also share his experiences of deploying the two technologies on everyone's favorite mini-sized computer, the Raspberry Pi. He will also present and discuss further ideas and possible solutions for creating efficient and optimized Web content presentation systems specifically crafted for embedded systems like Smart TVs and in-vehicle infotainment by using Linux, Wayland and WebKit.
How to test OpenGL drivers using Free Software (FOSDEM 2015)Igalia
By Samuel Iglesias.
OpenGL is an API for rendering 2D and 3D graphics now managed by the non-profit technology consortium Khronos Group. Implementors are free to provide their own implementation of the API. For example, in GNU/Linux systems NVIDIA provides its own proprietary version while other manufacturers like Intel are using Mesa, the most popular open source OpenGL implementation.
Because of this implementation freedom, ensuring compliance with the specification is important. Khronos provides their own OpenGL conformance test suite but there are several unofficial open source alternatives.
This talk will explain some of these open source OpenGL conformance test suites and give an introduction about how to use them, including sharing tips between the speaker and the audience.
(c) 2015 FOSDEM VZW
CC BY 2.0 BE
https://archive.fosdem.org/2015/
Brief introduction to Test Automation Frameworks, Acceptance Testing and ATTD using Testerone – custom made solution based on RobotFramework and it’s extensive libraries for Selenium’s and AutoIT’s support.
Bring the test cases closer to business people, leave the technical stuff to technical staff using simple business-to-tech excel sheet (map) for collaboration. Complete the solution by controlling everything using Jenkins CI server.
Refactoring legacy code driven by tests - ENGLuca Minudel
re you working on code poorly designed or on legacy code that’s hard to test? And you cannot refactor it because there are no tests?
During this Coding Dojo you’ll be assigned a coding challenge in Java, C#, Ruby, JavaScript or Python. You will face the challenge of improving the design and refactoring existing code in order to make it testable and to write unit tests.
We will discuss SOLID principles, the relation between design and TDD, and how this applies to your solution.
Reading list:
Growing Object-Oriented Software, Guided by Tests; Steve Freeman, Nat Pryce
Test Driven Development: By Example; Kent Beck
Working Effectively with Legacy; Michael Feathers
Agile Software Development, Principles, Patterns, and Practices; Robert C. Martin (C++, Java)
Agile Principles, Patterns, and Practices in C#; Robert C. Martin (C#)
- Highlight the performance benefits of using Java 8 - after all, you’ll probably have to persuade "The Management" that tampering with
existing code is worthwhile
- Demonstrate how to identify areas of code that can be updated to use Java 8 features, and how to pick which changes will give you the
most benefit
- Demonstrate how to automatically refactor your code to make use of features like lambdas and streams
- Cover some of the pros and cons of using the new features - including suggestions of when refactoring may NOT be the best idea.
Robot Framework is a generic keyword-driven test automation framework for acceptance level testing and acceptance test-driven development (ATDD). It has an easy-to-use tabular syntax for creating test cases and its testing capabilities can be extended by test libraries implemented either with Python or Java. Users can also create new keywords from existing ones using the same simple syntax that is used for creating test cases.
Old presentation was updated on 1st of September, 2014. Content stayed mostly the same but examples were enhanced. Copyrights and some links were also updated a bit later. The presentation is nowadays hosted on GitHub where you can find the original in ODP format: https://github.com/robotframework/IntroSlides
Practical tips for dealing with projects involving legacy code. Covers investigating past projects, static analysis of existing code, and methods for changing legacy code.
Presented at PHP Benelux '10
Pairing WebKit and Wayland for Linux-Based Embedded Web Content Presentation ...Igalia
By Žan Doberšek.
WebKit and its multi-process architecture might not seem suitable for embedded systems at first, but Wayland, the next-gen display system, has already proven itself by running efficiently on TVs, smartphones and single-board computers. This talk will present the techniques that were used to achieve efficient, hardware-accelerated rendering of Web content across the multiple processes of WebKit running under Wayland. Žan Doberšek will also share his experiences of deploying the two technologies on everyone's favorite mini-sized computer, the Raspberry Pi. He will also present and discuss further ideas and possible solutions for creating efficient and optimized Web content presentation systems specifically crafted for embedded systems like Smart TVs and in-vehicle infotainment by using Linux, Wayland and WebKit.
How to test OpenGL drivers using Free Software (FOSDEM 2015)Igalia
By Samuel Iglesias.
OpenGL is an API for rendering 2D and 3D graphics now managed by the non-profit technology consortium Khronos Group. Implementors are free to provide their own implementation of the API. For example, in GNU/Linux systems NVIDIA provides its own proprietary version while other manufacturers like Intel are using Mesa, the most popular open source OpenGL implementation.
Because of this implementation freedom, ensuring compliance with the specification is important. Khronos provides their own OpenGL conformance test suite but there are several unofficial open source alternatives.
This talk will explain some of these open source OpenGL conformance test suites and give an introduction about how to use them, including sharing tips between the speaker and the audience.
(c) 2015 FOSDEM VZW
CC BY 2.0 BE
https://archive.fosdem.org/2015/
GStreamer support in WebKit. What's new? (GStreamer Conference 2015)Igalia
By Philippe Normand.
This talk is about the current status of the GStreamer support in WebKit and how the latest GStreamer features are used in WebKit ports.
The talk will cover topics ranging from basic video rendering (with GstGL) to advanced features support required for adaptive streaming (Media Source Extensions) and content protection (Encrypted Media Extensions). An update on WebRTC support using the OpenWebRTC library might also be presented during the talk.
CSS Grid Layout is Just Around the Corner (CSSConf US 2015)Igalia
By Manuel Rego.
Slides at http://people.igalia.com/mrego/talks/cssconf-us-2015-css-grid-layout
Most websites nowadays have a grid based design using one of the many CSS frameworks that out there. The CSS Grid Layout standard is coming to the rescue, allowing web designers to easily create powerful and responsive two dimensional layouts while ensuring interoperability between browsers. This new spec is being implemented in all the major web engines and will be hitting your browsers soon. The talk will provide a detailed overview of the standard and its features, reviewing the current status in the main browsers and showcasing its capabilities with some nice examples. You will be introduced to the grid concepts and the new CSS properties required to use them. After the talk you will be ready to start playing and experimenting with grids on your websites.
Efficient multimedia support in QtWebKit on Raspberry Pi (GStreamer Conferenc...Igalia
By Philippe Normand and Miguel Gómez.
Since the Raspberry Pi platform was introduced it dramatically changed the picture of the embedded (affordable) micro-computer market.
WebKit is a popular Web rendering engine developed by a wide community of Open-Source developers including major actors such as Apple, Samsung, Intel and Adobe.
The purpose of this talk is to explain how we managed to leverage the hardware components of the Raspberry Pi to deliver acceptable video rendering performance of a QtWebKit(2) browser using the GStreamer 1.2.x APIs. We will explain how we integrated zero-copy rendering in the multi-process WebKit2 architecture. Other advanced use-cases such as video/canvas, video/webgl and getUserMedia will also be presented.
GStreamer-VAAPI: Hardware-accelerated encoding and decoding on Intel hardware...Igalia
By Víctor M. Jáquez.
Slides at https://github.com/01org/gstreamer-vaapi/tree/master/docs/slides/gstconf2015
GStreamer-VAAPI is a set of GStreamer elements (vaapidecode, vaapipostroc, vaapisink, and several encoders) and libgstvapi, a library that wraps libva under a GObject/GStreamer semantics.
This talk will be about VAAPI and its integration with GStreamer. We will show a general overview of VAAPI architecture, the role of libgstvaapi, and finally, the design of GStreamer elements. Afterwards we will show what is ahead in the development of GStreamer-VAAPI, and the current problems and challenges.
Spelunking through JPEG with Racket (Sixth RacketCon)Igalia
By Andy Wingo.
JPEG is a funny thing. Photos are our lives and our memories, our first steps and our friends, and yet how much do we know about how they work? This talk explores the JPEG format in a graphical way, using a Racket library to dissect, reconstruct, encode, and decode JPEG files.
This library was first written for Guile but then ported to Racket as an exercise. Along the way in the talk we can mention things that we really enjoy about Racket and other points of interest.
(c) Sixth RacketCon
18 Sept 2016
https://con.racket-lang.org/2016
Performance optimization techniques for Java codeAttila Balazs
The presentation covers the the basics of performance optimizations for real-world Java code. It starts with a theoretical overview of the concepts followed by several live demos
showing how performance bottlenecks can be diagnosed and eliminated. The demos include some non-trivial multi-threaded examples
inspired by real-world applications.
● What is Unit Testing?
● Benefits
● What is Test Driven Development?
● What is Behavior Driven Development?
● Categories of (Unit) Tests / Software Testing
Pyramid, Frameworks
● C++, Java, .NET, Perl, PHP frameworks
● Unit-testing Zend Framework application
Beyond unit tests: Deployment and testing for Hadoop/Spark workflowsDataWorks Summit
As a Hadoop developer, do you want to quickly develop your Hadoop workflows? Do you want to test your workflows in a sandboxed environment similar to production? Do you want to write unit tests for your workflows and add assertions on top of it?
In just a few years, the number of users writing Hadoop/Spark jobs at LinkedIn have grown from tens to hundreds and the number of jobs running every day has grown from hundreds to thousands. With the ever increasing number of users and jobs, it becomes crucial to reduce the development time for these jobs. It is also important to test these jobs thoroughly before they go to production.
We’ve tried to address these issues by creating a testing framework for Hadoop/Spark jobs. The testing framework enables the users to run their jobs in an environment similar to the production environment and on the data which is sampled from the original data. The testing framework consists of a test deployment system, a data generation pipeline to generate the sampled data, a data management system to help users manage and search the sampled data and an assertion engine to validate the test output.
In this talk, we will discuss the motivation behind the testing framework before deep diving into its design. We will further discuss how the testing framework is helping the Hadoop users at LinkedIn to be more productive.
The Popper Experimentation Protocol and CLI toolIvo Jimenez
Popper is a convention for conducting scientific explorations and writing academic articles following a DevOps approach. Popper allows researchers to automate the re-execution and validation of experimentation (computational and analysis) pipelines. This talk gives an overview and examples.
Performance Test Automation With GatlingKnoldus Inc.
Gatling is a lightweight dsl written in scala by which you can treat your performance test as a production code means you can easily write a readable code to test the performance of an application it s a framework based on Scala, Akka and Netty.
This presentation explores the benefits of functional programming, especially with respect to reliability. It presents a sample of types that allow many program invariants to be enforced by compilers. We also discuss the industrial adoption of functional programming, and conclude with a live coding demo in Scala.
Here are the slides from my tutorial on Scripting Recipes for Testers. In it I share a number of reusable scripts and some tips I learned writing them to help testers do their job better.
The scripts themselves can be found on my site (http://adam.goucher.ca) under the category 'GLSEC2008'
NovaProva, a new generation unit test framework for C programsGreg Banks
I wrote NovaProva because I was sick of writing unit tests using the venerable but clunky CUnit library. CUnit looked easy when I started writing unit tests but I soon discovered it's limitations and ended up screaming in frustration. Meanwhile over 18 months the Cyrus IMAP server project has gone from 0 unit tests to 461, of which 277 are written in C with CUnit. So that's a big itch!
Jay Luker will be presenting an introduction to Ghost Inspector, a cloud-based web UI testing service that takes some (some!) of the pain away from creating browser-based, web application tests. Think Selenium, but for projects that are short on the resources, infrastructure and/or coding expertise to confidently develop and manage a suite of fully automated, “good-enough” UI tests.
Jay is a Senior Software Engineer at Harvard DCE where he works on back-end applications and software for analytics data collection, deployment automation, and integration testing for the Extension School’s video processing and delivery system. Previously he has been an IT Specialist at the Smithsonian Astrophysics Data System, and a Software Developer at Ex Libris.
Ryan Goulding and Colin Dixon's presentation from the 2017 Open Networking Summit on Making Strongly-typed NETCONF Usable.
NETCONF's use of strongly-typed YANG to describe device configuration makes safe and robust device configuration possible, but also exposes complexities in operation. Most deployments choose to use a controller or management system to help with issues of inventory and credential management. Further, this controller often does sanity checks to ensure that operations are likely to be successful on devices and, if not, there is useful debugging information. Frustratingly, this exposes trade-offs between relying on strict enforcement of YANG to catching errors early and more relaxed behavior to enable compatibility with imperfect NETCONF implementations in the real world. We show how we navigated these trade-offs to provide a flexible, open-source NETCONF solution that is strongly-typed and enables simple configuration changes for compatibility with imperfect NETCONF implementations.
Test all the things! Automated testing with Drupal 8Sam Becker
With Drupal 8 released, one of the most important aspects of building a website or module has changed dramatically for the better. Developers now have a myriad of tools at their disposal to be able to test their code. If you are interested in improving your code and preventing bugs, but are unfamiliar with acronyms like BTB, KTB and WTB, this session is for you. If you’ve dabbled in testing but haven’t explored the depths of PHPUnit or Mink, then this session is for you.
Similar to Property-based testing an open-source compiler, pflua (FOSDEM 2015) (20)
A Year of the Servo Reboot: Where Are We Now?Igalia
Created by Mozilla Research in 2012 and now part of Linux Foundation Europe, the Servo project is an experimental rendering engine written in Rust. It combines memory safety and concurrency to create an independent, modular, and embeddable rendering engine that adheres to web standards. Stewardship of Servo moved from Mozilla Research to the Linux Foundation in 2020, where its mission remains unchanged. After some slow years, in 2023 there has been renewed activity on the project, with a roadmap now focused on improving the engine’s CSS 2 conformance, exploring Android support, and making Servo a practical embeddable rendering engine. In this presentation, Rakhi Sharma reviews the status of the project, our recent developments in 2023, our collaboration with Tauri to make Servo an easy-to-use embeddable rendering engine, and our plans for the future to make Servo an alternative web rendering engine for the embedded devices industry.
(c) Embedded Open Source Summit 2024
April 16-18, 2024
Seattle, Washington (US)
https://events.linuxfoundation.org/embedded-open-source-summit/
https://ossna2024.sched.com/event/1aBNF/a-year-of-servo-reboot-where-are-we-now-rakhi-sharma-igalia
Building End-user Applications on Embedded Devices with WPEIgalia
The Web engine is the most important component of a Web Browser, enabling
developers to harness the power of the Web Platform to build their
applications. However, Web Browsers are not the only type of applications that
can be built with Web Engines, which can also be used to develop other types of
applications using the same Web-based technologies, but for a different type of
use cases other than "browsing the Web".
These use cases can cover a wide range of situations outside of the traditional
desktop or mobile environments, such as the ones embedded systems are usually
used for (e.g. set-top-boxes, smart home appliances, GPS navigation devices, or
in-car/in-flight infotainment systems, to name a few). And in those situations
it is very common to be running on boards with SoCs and a particular set of HW
capabilities that make it crucial for the Web Engine to be able to tightly
integrate with them.
In this session we will focus on how WPE, a fully Open Source port of the
WebKit Web engine for Linux-based embedded devices, can be used to adapt to the
different challenges that embedded devices pose to develop end-user
applications, using the power of the Web Platform underneath.
(c) Embedded Open Source Summit 2024
April 16-18, 2024
Seattle, Washington (US)
https://events.linuxfoundation.org/embedded-open-source-summit/
https://eoss24.sched.com/event/1aNTr/building-end-user-applications-on-embedded-devices-with-wpe-mario-sanchez-prada-igalia
Raspberry Pi 5: Challenges and Solutions in Bringing up an OpenGL/Vulkan Driv...Igalia
The Raspberry Pi 5 was announced on October 2023. This new version of the
popular embedded device comes with a new iteration of Broadcom’s VideoCore GPU
platform, and was released with a fully open source driver stack, developed by
Igalia. The presentation will discuss some of the major changes required to
support this new Video Core iteration, the challenges we faced in the process
and the solutions we provided in order to deliver conformant OpenGL ES and
Vulkan drivers. The talk will also cover the next steps for the open source
Raspberry Pi 5 graphics stack.
(c) Embedded Open Source Summit 2024
April 16-18, 2024
Seattle, Washington (US)
https://events.linuxfoundation.org/embedded-open-source-summit/
https://eoss24.sched.com/event/1aBEx
Automated Testing for Web-based Systems on Embedded DevicesIgalia
Every day, embedded devices are becoming more powerful and capable of running
more elaborate applications. Among these applications are Web-based ones,
enabling to leverage features from the Web APIs to the embedded context, either
through a generic browser running a traditional Web application or through a
customized Web engine tightly integrated within the system.
But such capabilities usually bring new challenges, like testing user
interactions with the application using the embedded device's specific I/O
methods, such as gestures, or inspecting Web application internals with
JavaScript. In this context, using a browser automation framework such as
WebDriver, which is a W3C standard supported by WebKit Web engine, allows
testing Web-based applications on such devices as if the user were actually
using it, alongside running custom JS code.
In this session, we will cover why we need browser automation for testing on
certain types of embedded devices, with a focus on WebDriver as the proposed
tool to achieve that goal. We will also discuss WebDriver's main features and
limitations, as well as other possible approaches and frameworks that could be
considered for this kind of task.
(c) Embedded Open Source Summit 2024
April 16-18, 2024
Seattle, Washington (US)
https://events.linuxfoundation.org/embedded-open-source-summit/
https://eoss24.sched.com/event/1aeSx/automated-testing-for-web-based-systems-on-embedded-devices-lauro-moura-igalia
Embedding WPE WebKit - from Bring-up to MaintenanceIgalia
Embedded devices have become powerful enough to run Web content a decade ago,
and any modern SoC that can run Linux and includes a GPU is a potential
candidate to hide a Web engine under the surface. How did it made it there?
Does it only show Web content? What else can it do? The talk will cover
bring-up tips to build and get WPE WebKit working on your custom embedded
device and make your own simple Web browser, as well as the best practices for
keeping the system up to date. No less important is integration with the rest
of the system: this session will detail the possibilities that WebKit brings to
the table, including how to add new JavaScript APIs which call into native code
to provide tight, performant access to platform functionality.
(c) Embedded Open Source Summit 2024
April 16-18, 2024
Seattle, Washington (US)
https://events.linuxfoundation.org/embedded-open-source-summit/
https://eoss24.sched.com/event/1aBFQ/embedding-wpe-webkit-from-bring-up-to-maintenance-adrian-perez-de-castro-igalia
This talk dives into how the scheduler impacts your gameplay on Linux and
unveils our journey to smoother gameplay. How does task scheduling impact Linux
gaming? Suboptimal task scheduling can cause stuttering while playing games on
the Steam Deck game console. First, we nail down the enemy. What exactly is
"stuttering," and how can we measure its impact on your gameplay? Next, we
extensively analyzed the characteristics of game tasks from the scheduler’s
point of view. Characterizing task behavior in Linux gaming helps to understand
why some schedulers create much stuttering and others create less and to unveil
the secrets behind smooth vs. choppy performance. Lastly, we will share our
progress on the optimized scheduler for reducing the stuttering problems in
Linux gaming, especially Steam Deck. We implemented the scheduling policy based
on sched_ext, a BPF-based extensible scheduling framework.
(c) Open Source Summit North America 2024
April 16-18, 2024
Seatle, Washington (US)
https://events.linuxfoundation.org/open-source-summit-north-america/
https://ossna2024.sched.com/event/1aBOT/optimizing-scheduler-for-linux-gaming-changwoo-min-igalia
So, we are adding a backend for the SpiderMonkey’s codegen to enable JIT
support for JavaScript running through Wasm. Sounds a bit cryptic so let’s
divide it into parts.
SpiderMonkey is a JavaScript engine which is used for running JavaScript inside
the Firefox browser. SpiderMonkey is written in C++ and supports compilation
into the Wasm module, see live demo -
https://mozilla-spidermonkey.github.io/sm-wasi-demo/. However, SpiderMonkey
compiled into the Wasm module supports execution of JavaScript only in the
interpreter-only mode and it doesn’t support just-in-time compilation because
there is no Wasm backend for that. There are backends for Arm, X86, X64 etc but
there is none for Wasm.
Why do we want to add support for JIT? Well, because we want speed. Right now
there is no solution to run JS scripts via Wasm fast, there are only
interpreters.
Why does JIT improve performance?
The reasons are the same for why an interpreter is slower than a compiler -
because it eliminates the interpreter loop, uses a more efficient ABI and, more
importantly, it can specialize polymorphic operations in JavaScript. So, we not
only enable the JIT tier in SpiderMonkey for Wasm but we also provide support
for inline caches.
Inline caches is a mechanism for specializing the behavior of particular
operations like plus or a call to specific arguments provided at runtime.
With all that we can generate Wasm modules on the fly, instantiate them, and
link them to provide from ~2x to ~11x speedup over the interpreter. In the
talks we will cover how the whole scheme works with SpiderMonkey: 1. How to
link modules on the fly into SpiderMonkey.wasm 2. How to add an exotic Wasm
backend into SpiderMonkey’s supported backend line - X64, X86, Arm, Wasm 3. How
to use the whole solution in the cloud instead of QuickJS 4. How to get a
speedup of your JS over wasm with test data.
Wasm I/O 2024
14 - 15 Mar, 2024
Barcelona
https://2024.wasmio.tech/
To crash or not to crash: if you do, at least recover fast!Igalia
What could be possibly worse that an almost unbeatable boss in
a game or a tough maze that consume hours of gameplay with not
much progress? How about a Linux kernel crash that makes you
lose all the game progress with no apparent reason or feedback?
Though rare, it is a real possibility that would make gamers
quite annoyed, given that Linux is used more and more as a
platform for playing games.
Some technologies are available to collect logs and feedback
the user in case such disastrous events happen, mostly related
with kernel crashes handling mechanisms. The main ones available
are kdump and pstore, but still there are work to be done in
this area...
In this talk we're going to present the basics about kernel
crash handling, like how a kernel panic might happen, how to
deal with that (with an overall discussion about kdump and
pstore techs) and the kdumpst tool, developed specially to
deal with this situation on Steam Deck (and generically on
Arch Linux); also we're gonna discuss some missing
pieces / ideas to make it even less likely gamers need to
complain that their device just got hang for no reason!
FOSForums 2023
Aug 26 - Aug 27, 2023
Institute of Computing, State University of Campinas (Unicamp)
Campinas, São Paulo, Brazil
https://www.fosforums.org/
Introducción a Mesa. Caso específico dos dispositivos Raspberry Pi por IgaliaIgalia
Nesta charla impartida por Alejandro Piñeiro de Igalia, darase unha introdución
a Mesa, librería open-source para o desenvolvemento de drivers gráficos.
Explicarase a súa historia, os seus compoñentes máis importantes, que
utilidades proporcionan aos desenvolvedores e unha lista de hardware ás que dan
soporte. Finalmente explicarase o caso concreto do soporte proporcionado para
as GPUs dos dispositivos da serie Raspberry Pi, centrándonos nas Raspberry Pi 4
e Raspberry Pi 5
Igalia é unha empresa galega, con sede na Coruña, especializada en servizos de
consultoría, e que desenvolve solucións innovadoras de código aberto para un
gran conxunto de plataformas de software e hardware. En Igalia traballan nas
áreas máis interesantes do software de código aberto, incluídos navegadores,
gráficos e multimedia.
Igalia desenvolveu os controladores OpenGL ES 3.1 e Vulkan 1.2 conformes para a
GPU VideoCore VII Broadcom que se fornece coa nova Raspberry Pi 5.
Alejandro Piñeiro é enxeñeiro de Software e socio en Igalia, é desenvolvedor de
Software Libre desde 2004. A súa experiencia inclúe unha variedade de proxectos
de GNOME e freedesktop.org, enfocándose desde 2015 en Mesa, especificamente os
drivers Intel e Broadcom. É un dos responsables do desenvolvemento do
controlador Broadcom Vulkan para Raspberry Pi 4 & 5.
Máis información en https://aindustriosa.org/Mesa/
Esta actividade está patrocinada pola Xunta de Galicia e pola Axencia Para a
Modernización Tecnolóxica (AMTEGA).
(c) A Industriosa
https://aindustriosa.org
28 de Outubro (Vigo)
Chimera Linux is a novel Linux distribution built around FreeBSD core tools and
the LLVM toolchain. Since its initial launch in 2021, it has made a lot of
progress and is now in alpha stage. The system can be deployed on a wide array
of hardware and many people are using it as their desktop system; it works on
x86_64, AArch64, POWER (little and big endian) as well as RISC-V and by now
comes with thousands of packages.
While trying to be practical, Chimera is also highly hardened, partly thanks to
the LLVM toolchain, rendering it immune to various security issues other
distros are vulnerable to. It has transparent and robust infrastructure,
ensuring smooth deployment of packages. We are also developing various new
tooling that the whole ecosystem can benefit from, including the Turnstile
session tracker. Service management is based around Dinit, a modern,
supervising system; we maintain and create a variety of tooling around it,
trying to break the existing status quo with systemd, while abandoning legacy
approaches.
2023 has seen several major milestones, so I will focus on these, while also
giving a short overview so that people unfamiliar with the system don't feel
lost. I will also explain how our work benefits the entire Linux ecosystem, as
well as beyond.
(c) FOSDEM 2024
3 & 4 February 2024
https://fosdem.org/2024/schedule/event/fosdem-2024-2524-2023-in-chimera-linux/
For the last 3 years, I've been building a complete Linux distribution, Chimera
Linux (https://chimera-linux.org) using solely LLVM as its system toolchain -
that means Clang, compiler-rt, and libc++, alongside its other tooling. Right
now, it is a complete desktop system that is already used by many, with a
familiar GNOME interface and thousands of packages, targeting 5 CPU
architectures. In this talk I would like to focus on my experiences using the
toolchain, what obstacles got in the way, how I dealt with them, the issues
that are still left and I would like to see addressed, the many benefits using
LLVM gave the project, and overall give the audience an insight into practical
deployment of LLVM in a project where it isn't simply a drop-in alternative to
GCC.
(c) FOSDEM 2024
3 & 4 February 2024
https://fosdem.org/2024/schedule/event/fosdem-2024-2555-building-a-linux-distro-with-llvm/
turnip: Update on Open Source Vulkan Driver for Adreno GPUsIgalia
Turnip changed a lot since the last status update. You could now run AAA
desktop games via FEX + Turnip, Adreno 7xx is now supported, Turnip is used by
emulators on Android, and more!
(c) FOSDEM 2024
3 & 4 February 2024
https://fosdem.org/2024/schedule/event/fosdem-2024-2033-turnip-update-on-open-source-vulkan-driver-for-adreno-gpus/
Graphics stack updates for Raspberry Pi devicesIgalia
This talk will show the efforts done in the Open-Source graphics stack for
supporting Raspberry Pi devices. Although the talk will focus on the recently
launched new Raspberry Pi 5, we will show the improvements done for previous
generations of the Raspberry Pi hardware.
Raspberry Pi 5 has available FLOSS GPU drivers on product launch, exposing
OpenGL-ES 3.1 and Vulkan 1.2. We'll go through the changes needed to enable
desktop OpenGL 3.1 on RPi4/5.
We will also review the changes done to the kernel driver to expose the RPi5
capabilities and the new GPU stats support for RPi4/5.
Finally, we will show the work done to use Wayfire as the default Wayland
compositor on the Raspberry Pi OS.
- https://www.mesa3d.org/
- https://www.raspberrypi.com/
- https://wayfire.org/
(c) FOSDEM 2024
3 & 4 February 2024
https://fosdem.org/2024/schedule/event/fosdem-2024-2841-graphics-stack-updates-for-raspberry-pi-devices/
Delegated Compositing - Utilizing Wayland Protocols for Chromium on ChromeOSIgalia
This talk will cover our experience in utilizing Wayland subsurfaces and
implementing delegated compositing for Chromium on ChromeOS. Several concepts
will be covered - from overlay making decision in Chromium/Viz to design and
implementation of custom Wayland protocols, which were required to pass frame
data as overlays via Wayland and reconstruct that frame on the Wayland server
side.
(c) FOSDEM 2024
3 & 4 February 2024
https://fosdem.org/2024/schedule/event/fosdem-2024-3177-delegated-compositing-utilizing-wayland-protocols-for-chromium-on-chromeos/
MessageFormat: The future of i18n on the webIgalia
Internationalization in JavaScript and on the web platform is very complicated,
but also vastly important for us developers in order to build accessible and
intelligible interfaces. Thankfully, Unicode Consortium's MessageFormat working
group and TC39 have been hard at work standardizing the next generation of i18n
tooling that aims to unify analogous non-standard tools in use today while
approaching this problem from a fresh perspective.
Join me along this tour of i18n in JavaScript, discover some of the newest
additions to the toolkit and learn about the ongoing MessageFormat proposal and
how it aims to radically improve the developer experience.
(c) FOSDEM 2024
3 & 4 February 2024
https://fosdem.org/2024/schedule/event/fosdem-2024-2832-messageformat-the-future-of-i18n-on-the-web/
Replacing the geometry pipeline with mesh shadersIgalia
This talk will discuss the problems with the traditional vertex processing
pipeline and present how mesh shading solves these problems. Instead of
processing a fixed set of input vertices, mesh shaders can create an arbitrary
topology of vertices and primitives. Mesh shading also includes a new solution
for geometry amplification: task shaders.
The talk should be scheduled before Timur's talk about implementing mesh
shaders in the RADV Mesa driver.
(c) X.Org Developer Conference (XDC) 2022
October 4-6, 2022
Minneapolis, Minnesota, USA
https://indico.freedesktop.org/event/2/
Let's talk about developing AMD display drivers in the DRM subsystem as an
external contributor. Part of this work is a trail of breadcrumbs to build
documentation. What are those breadcrumbs? How do they help to review, fix,
improve and enable features of AMD drivers? How would both sides benefit if
those pieces of information were already documented? We are gathering
information from anywhere and also bothering experts for input. Ultimately,
this presentation focuses on AMD driver development but may fit DRM drivers of
any GPU vendors.
(c) X.Org Developer Conference (XDC) 2022
October 4-6, 2022
Minneapolis, Minnesota, USA
https://indico.freedesktop.org/event/2/
There has been a lot of activity in V3DV, the Vulkan driver for Raspberry Pi 4,
over the last year: we have significantly reworked our synchronization code,
obtained Vulkan 1.1 conformance, implemented Vulkan 1.2 support, continued to
work on compiler optimizations and more.
In this talk I would like to go through the main development milestones and
changes we implemented in the driver as well as discussing some limitations of
the underlying hardware platform that have discouraged us from implementing
features such as scalar block layout or fp16.
(c) X.Org Developer Conference (XDC) 2022
October 4-6, 2022
Minneapolis, Minnesota, USA
https://indico.freedesktop.org/event/2/
Generating a custom Ruby SDK for your web service or Rails API using Smithyg2nightmarescribd
Have you ever wanted a Ruby client API to communicate with your web service? Smithy is a protocol-agnostic language for defining services and SDKs. Smithy Ruby is an implementation of Smithy that generates a Ruby SDK using a Smithy model. In this talk, we will explore Smithy and Smithy Ruby to learn how to generate custom feature-rich SDKs that can communicate with any web service, such as a Rails JSON API.
The Art of the Pitch: WordPress Relationships and SalesLaura Byrne
Clients don’t know what they don’t know. What web solutions are right for them? How does WordPress come into the picture? How do you make sure you understand scope and timeline? What do you do if sometime changes?
All these questions and more will be explored as we talk about matching clients’ needs with what your agency offers without pulling teeth or pulling your hair out. Practical tips, and strategies for successful relationship building that leads to closing the deal.
LF Energy Webinar: Electrical Grid Modelling and Simulation Through PowSyBl -...DanBrown980551
Do you want to learn how to model and simulate an electrical network from scratch in under an hour?
Then welcome to this PowSyBl workshop, hosted by Rte, the French Transmission System Operator (TSO)!
During the webinar, you will discover the PowSyBl ecosystem as well as handle and study an electrical network through an interactive Python notebook.
PowSyBl is an open source project hosted by LF Energy, which offers a comprehensive set of features for electrical grid modelling and simulation. Among other advanced features, PowSyBl provides:
- A fully editable and extendable library for grid component modelling;
- Visualization tools to display your network;
- Grid simulation tools, such as power flows, security analyses (with or without remedial actions) and sensitivity analyses;
The framework is mostly written in Java, with a Python binding so that Python developers can access PowSyBl functionalities as well.
What you will learn during the webinar:
- For beginners: discover PowSyBl's functionalities through a quick general presentation and the notebook, without needing any expert coding skills;
- For advanced developers: master the skills to efficiently apply PowSyBl functionalities to your real-world scenarios.
Kubernetes & AI - Beauty and the Beast !?! @KCD Istanbul 2024Tobias Schneck
As AI technology is pushing into IT I was wondering myself, as an “infrastructure container kubernetes guy”, how get this fancy AI technology get managed from an infrastructure operational view? Is it possible to apply our lovely cloud native principals as well? What benefit’s both technologies could bring to each other?
Let me take this questions and provide you a short journey through existing deployment models and use cases for AI software. On practical examples, we discuss what cloud/on-premise strategy we may need for applying it to our own infrastructure to get it to work from an enterprise perspective. I want to give an overview about infrastructure requirements and technologies, what could be beneficial or limiting your AI use cases in an enterprise environment. An interactive Demo will give you some insides, what approaches I got already working for real.
Elevating Tactical DDD Patterns Through Object CalisthenicsDorra BARTAGUIZ
After immersing yourself in the blue book and its red counterpart, attending DDD-focused conferences, and applying tactical patterns, you're left with a crucial question: How do I ensure my design is effective? Tactical patterns within Domain-Driven Design (DDD) serve as guiding principles for creating clear and manageable domain models. However, achieving success with these patterns requires additional guidance. Interestingly, we've observed that a set of constraints initially designed for training purposes remarkably aligns with effective pattern implementation, offering a more ‘mechanical’ approach. Let's explore together how Object Calisthenics can elevate the design of your tactical DDD patterns, offering concrete help for those venturing into DDD for the first time!
UiPath Test Automation using UiPath Test Suite series, part 4DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 4. In this session, we will cover Test Manager overview along with SAP heatmap.
The UiPath Test Manager overview with SAP heatmap webinar offers a concise yet comprehensive exploration of the role of a Test Manager within SAP environments, coupled with the utilization of heatmaps for effective testing strategies.
Participants will gain insights into the responsibilities, challenges, and best practices associated with test management in SAP projects. Additionally, the webinar delves into the significance of heatmaps as a visual aid for identifying testing priorities, areas of risk, and resource allocation within SAP landscapes. Through this session, attendees can expect to enhance their understanding of test management principles while learning practical approaches to optimize testing processes in SAP environments using heatmap visualization techniques
What will you get from this session?
1. Insights into SAP testing best practices
2. Heatmap utilization for testing
3. Optimization of testing processes
4. Demo
Topics covered:
Execution from the test manager
Orchestrator execution result
Defect reporting
SAP heatmap example with demo
Speaker:
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
Transcript: Selling digital books in 2024: Insights from industry leaders - T...BookNet Canada
The publishing industry has been selling digital audiobooks and ebooks for over a decade and has found its groove. What’s changed? What has stayed the same? Where do we go from here? Join a group of leading sales peers from across the industry for a conversation about the lessons learned since the popularization of digital books, best practices, digital book supply chain management, and more.
Link to video recording: https://bnctechforum.ca/sessions/selling-digital-books-in-2024-insights-from-industry-leaders/
Presented by BookNet Canada on May 28, 2024, with support from the Department of Canadian Heritage.
Epistemic Interaction - tuning interfaces to provide information for AI supportAlan Dix
Paper presented at SYNERGY workshop at AVI 2024, Genoa, Italy. 3rd June 2024
https://alandix.com/academic/papers/synergy2024-epistemic/
As machine learning integrates deeper into human-computer interactions, the concept of epistemic interaction emerges, aiming to refine these interactions to enhance system adaptability. This approach encourages minor, intentional adjustments in user behaviour to enrich the data available for system learning. This paper introduces epistemic interaction within the context of human-system communication, illustrating how deliberate interaction design can improve system understanding and adaptation. Through concrete examples, we demonstrate the potential of epistemic interaction to significantly advance human-computer interaction by leveraging intuitive human communication strategies to inform system design and functionality, offering a novel pathway for enriching user-system engagements.
Smart TV Buyer Insights Survey 2024 by 91mobiles.pdf91mobiles
91mobiles recently conducted a Smart TV Buyer Insights Survey in which we asked over 3,000 respondents about the TV they own, aspects they look at on a new TV, and their TV buying preferences.
How world-class product teams are winning in the AI era by CEO and Founder, P...
Property-based testing an open-source compiler, pflua (FOSDEM 2015)
1. Property-based testing an
open source compiler, pflua
A fast and easy way to find bugs
kbarone@igalia.com ( luatime.org )
www.igalia.com
Katerina Barone-Adesi
2. Summary
● What is property-based testing?
● Why is it worth using?
● Property-based testing case study with pflua,
an open source compiler
● How do you implement it in an afternoon?
● What tools already exist?
3. Why test?
● Reliability
● Interoperability
● Avoiding regressions
● … but this is the test room, so
hopefully people already think testing
is useful and necessary
4. Why property-based testing?
● Writing tests by hand is slow, boring,
expensive, and usually doesn't lead to
many tests being written
● Generating tests is cheaper, faster,
more flexible, and more fun
● Covers cases humans might not
5. Why is it more flexible?
● Have you ever written a set of unit
tests, then had to change them all by
hand as the code changes?
● It's a lot easier and faster to change
one part of test generation instead!
6. What is property-based testing?
● Choose a property (a statement that
should always be true), such as:
● somefunc(x, y) < 100
● sort(sort(x)) == sort(x) (for stable sorts)
● run(expr) == run(optimize(expr))
● our_app(input) == other_app(input)
7. What is property-based testing not?
● A formal proof
● Exhaustive (except for very small types)
● What that means: property-based testing tries
to find counter-examples. If you find a counter-
example, something is wrong and must be
changed. If you don't, it's evidence (NOT proof)
towards that part of your program being correct.
8. Why not exhaustively test?
● Too difficult
● Too expensive
● Too resource-consuming (human and computer
time)
● Formal methods and state space reduction
have limitations
9. What is pflua?
● Pflua is a source to source compiler
● It takes libpcap's filter language (which we call
pflang), and emits lua code
● Why? This lets us run the lua code with luajit
● Performance: better than libpcap, often by a
factor of two or more
● https://github.com/Igalia/pflua/
● Apache License, Version 2.0
10.
11. What is pflang?
● The input for pflua, libpcap, and other tools
● Igalia's name for it, not an official name
● A language for defining packet filters
● Examples: “ip”, “tcp”, “tcp port 80”, …
● tcp port 80 and not host 192.168.0.1
● If you've used wireshark or tcpdump,
you've used pflang
12. Case study: testing pflua
● Pflua already had two forms of testing,
and works in practice
● Andy Wingo and I implemented a
property-based checker in an
afternoon, with one property...
13. What was the test property?
● lua code generated from optimized and
unoptimized IR has the same result on the
same random packet
● It compared two paths:
● Input → IR → optimize(IR) →
compile → run()
● Input → IR → (no change) →
compile → run()
14. What happened?
● We found 6/7 bugs
● Some are ones we were unlikely to
find with testing by hand
● Remember: pflua is an already-tested,
working project
15. What were the bugs?
● Accidental comments: 8--2 is 8, not 10! (Lua)
● Invalid optimization: ntohs/ntohl
● Generating invalid lua (return must end block)
● Range analysis: range folding bug (→ inf)
● Range analysis: not setting range of len
● Range analysis: NaN (inf – inf is not your friend)
● + a Luajit bug, found later by the same test
16. Case study recap
● Property-based testing is useful even for
seemingly-working, seemingly-mature code
● We found 3 bugs in range analysis
● We were unlikely to have found all 3 bugs with
unit testing by hand
● This was code that appeared to work
● Typical use didn't cause any visible problem
● 4 of the 6 bugs fixed that afternoon
17. Property-based testing: how?
● for i = 1,100 do
local g = generate_test_case()
run_test_case(property, g)
● Conceptually, it's that simple:
Generate and run tests (handling exceptions)
● With premade tools, you need a property,
and (sometimes) a random test generator
18. How to generate test cases
● The simplest version is unweighted choices:
function True() return { 'true' } end
function Comparison()
return { ComparisonOp(), Arithmetic(),
Arithmetic() } end
…
function Logical()
return choose({ Conditional, Comparison,
True, False, Fail })() end
19. Are unweighted choices enough?
● math.random(0, 2^32-1)
● Property: 1/y <= y
● False iff y = 0
● 4 billion test cases doesn't guarantee this will
be found...
● What are other common edge case numbers?
21. Write your own checker!
for i = 1,iterations do
local packet, packet_idx = choose(packets)
local P, len = packet.packet, packet.len
random_ir = Logical()
local unopt_lua = codegen.compile(random_ir)
local optimized = optimize.optimize(random_ir)
local opt_lua = codegen.compile(optimized)
if unopt_lua(P, len) ~= opt_lua(P, len)
then print_details_and_exit() end
end
22. Test generation problems
● Large, hard-to-analyze test cases
● Defaults to randomly searching the
solution space; randomly testing that
plain 'false' is still 'false' after
optimization as 20% of your 1000
tests is a bit daft
23. What level to test?
● For a compiler: the front-end language? Various
levels of IR? Other?
● In general: input? Internal objects?
● Tradeoffs: whitebox testing with internals can
be useful, but can break systems with internals
that the system itself cannot create.
● Testing multiple levels is possible
● Tends to test edge cases of lower levels
24. Interaction with interface stability
● At any level, more flexible than hand unit
testing
● Interfaces change. Inputs hopefully change
rarely; internals may change often
● Property-based testing makes refactoring
cheaper and easier: less code to change when
internals change, more test coverage
25. It's still worth unit testing
● Use property-based testing to find bugs (and
classes of bugs)
● Use unit tests for avoiding regressions;
continue to routinely test code that has already
caused problems, to reduce the chances that
known bugs will be re-introduced
● Use unit testing if test generation is infeasible,
or for extremely rare paths
26. Reproducible tests
● There are some pitfalls to outputting a
random seed to re-run tests
● The RNG may not produce consistent
results across platforms or be stable
across upgrades
● (Rare) Bugs in your compiler / interpreter
/ libraries can hinder reproducibility
27. Existing tools: QuickCheck
● Originally in Haskell; has been widely ported to
other languages
● Better tools for test case generation
● Allows filtering test cases
● Starts with small test cases
● QuickCheck2: test case minimization
28. The future of test generation
● Hypothesis, by David Ritchie MacIver (Python)
● https://github.com/DRMacIver/hypothesis
● Example database is better than saving seeds - it
propagates interesting examples between tests.
● Much smarter data generation
● Adapts to conditional tests better
● Blurs the lines between fuzz testing, conventional
unit testing and property based testing.
29. Forward-looking Hypothesis
● The following are planned, but not implemented
● Using coverage information to drive example
generation
● Adding "combining rules" which allow you to
also express things like "set | set -> set" and
then it can test properties on those too.
● Better workflows around integrating into CI
● End-of-February 1.0 release predicted
30. Other stable tools
● Scalacheck
● Quviq's Quickcheck for Erlang
● Have/inspired some of the benefits of
Hypothesis, but are already mature and widely
used
31. Conclusions
● Property-based testing finds tricky bugs and
saves time
● You can start it in an afternoon, with no tools
● There are some pretty helpful existing tools
(QuickCheck, Hypothesis, ScalaCheck, etc)
● Start property-based testing today!
● Or Monday, at least.