yamadapc

Nice, I built a similar toy with RNBO - https://knobs-gallery.vercel.app/harmonics

https://rnbo.cycling74.com/

Interesting! Any plans to release rust audio-unit hosting source-code?

This is the experience team-managed projects should have out of the box in Cloud if using kanban.

You create a kanban team-managed project and it'll pretty much be a Trello board. If you want sprints or a backlog or reports you can go into the project features page and flip a switch.

Jira/Confluence Cloud use the same markup and editor.

Nice post, thanks

Thanks for sharing lukastyrychtr

It's completely frozen for me (after downloading), but it's very cool for sure

I’ll plug my own fast OSX scanner, though “storage management” got better recently (or I hadn’t noticed when using it initially).

https://beijaflor.io/blog/06-2020/filesaver-freeing-up-space...

I’m not a C++ developer so the code can need improvements

TL;DL

Ignore all existing literature and experts' previous experience.

Simple.

You can just wrap `fetch` with something that knows where your server is. In `Este.js` there's something like:

    function ensureServerUrl(url) {
      // parse and replace with your server url
      // in Este you read from a SERVER_URL environment variable
    }

    function fetch(url, options) {
      url = ensureServerUrl(url);
      return fetch(url, options);
    }

You can also generate the types and parsers from a data sample.

In Haskell you can generate a parser to a typed structure using library combinators and code generation:

    data DataMessage = DataMessage { company :: Text
                                   }
      deriving (Show)
    $(deriveJSON defaultOptions ''DataMessage)

    data DataList = DataList { _data :: [DataMessage]
                             }
      deriving (Show)
    $(deriveJSON defaultOptions { fieldLabelModifier = drop 1 } ''DataList)

Which will fail properly when the data is malformed and in the real-world is even shorter, because you can set your data-type to protocol naming conventions and share them throughout.

Then there isn't much bloat. You wrote your types and generated your way to parse them.

You could test with:

    main = do
        print (encode (DataMessage "some-company"))
        print (decode "{\"company\":\"some-company\"}" :: Maybe DataMessage)

        print (encode (DataList [DataMessage "c1", DataMessage "c2", DataMessage "c3"]))
        print (decode "{\"data\":[{\"company\":\"c1\"},{\"company\":\"c2\"}]}" :: Maybe DataList)

https://gist.github.com/b30f6f09a737dcc980e052b0f3d2a39e

The D Language (http://dlang.org/) has a @nogc pragma (https://dlang.org/spec/attribute.html#nogc).

You just annotate functions that you don't want to use the GC in with it and it'll assert that they don't use it.

SQL...?

As the article seems to be down, here's the text-only (google) cached version:

http://webcache.googleusercontent.com/search?q=cache:CTMc7ZQ...