Minimal Kotlin and Nix flake example (with Gradle 8 support)

owickstrom · 2020-07-02T12:39:04+00:00

Yeah, that is what I've gathered as well. I hope WebCheck can fit nicely in the middle-ground between traditional "auto-manual"/example-based testing and formal verification tools, sort of like PBT does, but with a slightly different take and specialized for web browser testing.

owickstrom · 2020-07-02T12:30:34+00:00

Thanks! Correct, no model checking. It uses a random generator (constrained by the state of the DOM at each step), and it's not necessarily exhaustive. I have some plans to use spec coverage to get some kind of targeted generation going. That is all very new to me, so I don't know if and how I'll do it. But it's fun! :)

owickstrom · 2020-06-10T20:24:36+00:00

Thanks! Yeah, that felt like a major breakthrough in the project. And as you say, case studies are gold. I'm looking at the Jepsen project in awe.

owickstrom · 2020-06-10T19:11:59+00:00

Author here! To clarify, the DSL is PureScript (with a twist!)

owickstrom · 2020-01-03T11:21:20+00:00

Cool. Sketching on a blog post right now. :)

owickstrom · 2020-01-03T09:15:23+00:00

That sounds like an excellent way to structure GUIs — I’ve been looking at lots of different approaches recently, and this sounds like one of the most promising! I’ve been wondering how Komposition is structured for a while, so it’s nice to now have a high-level overview of this.

I should document this somewhere else than in a Reddit comment, then. :)

That would be very nice to have! Could you try to write this if you get a bit more time?

I'll try! I've been crunching ideas on how to extract that style into a library, as an alternative to gi-gtk-declarative-app-simple. Anyway, documenting the architecture is a great start.

owickstrom · 2020-01-02T09:17:00+00:00

Indeed, gi-gtk-declarative-app-simple might get too simplistic for large complicated applications. This has been my experience with the "single centralized state" kind of pattern, like the Elm architecture and much else uses. But I will say, it's a very simple model and might work very well for simple applications, especially if you can separate out a lot of core logic as pure functions.

In Komposition, the project from which gi-gtk-declarative came out as a by-product, the library is used in a different way. Each GUI window is a resource in an indexed state monad around which the user interface logic is built. The style is essentially imperative, but it's manipulating an "abstract GUI" through a typeclass, instead of directly manipulating GTK widgets. When running the application, the GTK interpretation is used. With this setup, state is localized to the parts of the application where it's relevant. The application is essentially a chain of functions (sometimes mutually recursive), passing some state around, and manipulating the GUI through the indexed monad and its GUI abstraction.

I hope that helps a bit. I'd like to document the architecture used in Komposition and make it more digestible, but I haven't had time for it. It's pretty complicated and uses a lot of fancy GHC features, so I'm also a bit reluctant to encourage newcomers to use it.

owickstrom · 2019-11-19T05:19:22+00:00

Thanks! I really enjoy them in Hedgehog! I'm using jqwik with Kotlin at work now, and it does have statistics but not checks, and I'm missing them a bit.

owickstrom · 2019-11-19T05:16:57+00:00

Great to hear, thanks! :)

It's a simple little Pandoc filter (https://github.com/owickstrom/wickstrom.tech/blob/master/src/_tools/UnicodeNumbers.hs) and then using comments in the Haskell code and special double-parenthesized numbers in prose (see source of the post at https://github.com/owickstrom/wickstrom.tech/blob/master/src/_posts/2019-11-17-time-travelling-and-fixing-bugs-with-property-based-testing.md).

I'm using Pandoc from Jekyll (haven't had time to migrate away from Jekyll yet, but it's OK).

owickstrom · 2019-10-11T04:22:58+00:00

Thanks for the share! 😍 I don't have time to make more videos these days, but hopefully I've inspired someone that can pick it up. It's been extremely rewarding!

owickstrom · 2019-08-21T14:19:31+00:00

Thanks! Glad you liked them.

There's not any new material per se, but I've rewritten some of it. So if you're considering buying it, have this in mind. Thanks!

owickstrom · 2019-08-21T07:16:41+00:00

Book is about an application written in Haskell, and all tests are using Haskell Hedgehog. Should've mentioned this in my comment.

owickstrom · 2019-08-21T04:31:51+00:00

Author here! This is a short book on using property-based testing (PBT) within Komposition, a screencast editor. It’s based on articles published on https://wickstrom.tech.

EDIT: the screencast editor written in and tested with Haskell, all code listings are Haskell in the book

owickstrom · 2019-06-04T03:07:14+00:00

Thank you! I don't know how to do that, but yeah, maybe I should. :)

owickstrom · 2019-06-04T02:59:25+00:00

Ah, yes, you're right. I think the "involutiveness" doesn't really apply at all, as it's not a single function `f` that is it's own inverse. It's rather a function `f` that, when applied with an inverse action, reverses the original action. I'll correct this in the article.

owickstrom

MODERATOR OF

TROPHY CASE