Back to 2 min. Multiline case statements https://vimeo.com/810651250

Highligthing in VSCode and a tiny full stack webapp in Firefly. Frontend, backend & assets in a single file < 100 lines.

I've started using my languge to write the documentation page for itself. The cool bit is the fact I can reference parts of the AST and render them in page, so the example are not made up but just parts of the standard library. https://vimeo.com/814332459 The actual docs live at https://language.web.petersaxton.uk/

Type inference on hover for Firefly

Some Flyde progress: • Run flow from the editor itself! (before that, you had to write some code to load the flow and trigger it yourself • 5 "New flow" templates - from HTTP examples to a memoized recursive Fibonacci sequence 🤓 • Some general UI tweaks (Large "part menu", hotkeys screen) (no sound)

Autocomplete exhaustive patterns for Firefly

Beginnings of a computational notebook built with my natural language structure editor workbench ™️

2023-04-26_15-30-14.mkv

Demonstrating a prototype of the capability permission system for mech. Anyone out here have experience implementing a system like this? Any pointers or tips?

Something I've been wanting to play with for a long white! A naive integration of OpenAI into Flyde ✨ It generates a file that implements a Flyde "Code Part" based on a prompt. Too slow and far from perfect, but hey.. it works 😄

Contributing to the @Lu Wilson Cinematic Universe

> Outlines in > Outlines in > Outlines

- Enter deeply nested objects/arrays - Leave by using breadcrumbs at the top - Paginate objects/arrays - Collapse/Expand children - Do operations at any level - State survives data updates

LSP experience of writing the webserver that redirects http://firefly-lang.org/ to https://www.firefly-lang.org/

Improved the interface, fixed event reasoning, and restyled the scenario editor to look like a Gov't of Canada webpage. Code in the picture, result in the gif.

I've built a structured editor using go for my language. This one is a TUI based interface. https://vimeo.com/827006232?share=copy

HitchStory is an open source bolt-on for pytest that, lets you build integration tests which autogenerate scenario-based documentation about your app. The tests are written in type-safe StrictYAML. In the website example, running the tests generates screenshots and a GIF of the user story from playwright. These are all combined into step-by-step markdown documentation that non developers can follow that explain how your app works. More here: https://github.com/hitchdev/hitchstory (including locally runnable code examples testing a REST API and a command line interface).

This weeks development actually sharing my language so other people have a chance to use it. https://vimeo.com/829141501?share=copy

This is what has been preoccupying my mind this week. Using ProseMirror to build a WYSIWYG web editor prototype that is compliant with a subset of the LegalDocML OASIS standard. Wanted to get a better idea of the complexity. GPT4 was more useful than the docs, it turns out. https://GitHub.com/Lexpedite/lawmirror

Since it’s the weekend I think it’s fitting to post something a bit ridiculous 🙂 It’s a combination of a universal text highlighter & blocks highlighter in our ‘infinite’ canvas app

This is a relatively simple concept but I think it’s quite powerful. In Nette we try to allow users to grab anything that looks like interesting information and then drop it on canvas (we will turn it into the right type of blocks). Here we have “X-Ray” 😎 Essentially Named Entity Recognition, which *adds affordances to recognised phrases*—you can then drop any of them onto the canvas and we’ll try to make a Definition block out of it. This is what it looks like 🙂

Generating initial content for an any workspace. We are, by design, about non-linear explorations, in that setting it’s not always easy to start. A bit like sitting in front of a blank page. This feature is like priming / toning the canvas 😉 I personally think visually a lot of the time (spatially / moving pictures), but the trigger for starting a thread of thought is quite often a word, term, phrase or a sentence. This feature is about that kind of exploration, you drop a word and it ripples out into all kinds of useful directions. (of course, being useful is the trick here, this is very minimal atm) The way the app is set-up it’s not difficult for us to generate those workspaces (the blocks are Clojure maps in a re-frame db), so if it turns out that it’s useful we’ll probably generate more content.

A super simple demo, of a super simple feature. (more of an experiment really) The assumptions is that an infinite canvas is great for creative / generative tasks. But then for processing a linear workflow, might be better / more natural / impose less cognitive burden. That is what we’re trying to explore with ‘Zen Mode’ 😉

Web apps, New effect types in code sandbox (HTTP, Async and Log) and Shallow effect handlers added to my language. https://vimeo.com/840125548

I've added eval to my language in the last week. Trying to get my head around supercompilation so I can precompute terms that are evaled and then have typesafe

string.format

Does any language make use of this eval at compiletime to reduce untypable functions, like eval. https://vimeo.com/842275363?share=copy

Hi, I am experimenting with functionality to be able to inspect "path executions" in a visual flow (the flow in the video is adding random values to an array of which the total sum is calculated): in the short video you can see me inspecting the last executed path with the slider on the bottom.. with this you can inspect the different stages of an executed path. After a flow has been run, the last path can be inspected. With the slider on the right you can switch between paths which have been executed before. In the beginning of the video I've pressed the 'run' button multiple times, all these executions can be inspected with this slider.. and the current execution path that is being inspected can be inspected further with the slider on the bottom.

My language is now "JSON complete" https://vimeo.com/846295379?share=copy which I think counts as a reasonable stepping stone on the way to packman complete

I've implemented a Lisp REPL/Shell for accessing my deployment infrastructure and other parts of my personal compute resources. It uses the same AST/interpreter as the rest of EYG. https://vimeo.com/861001803?share=copy

Folding & Unfolding UIs Prototype 💡 Get the simplest UI possible for the level of detail you need 🪗 Unfold UI components to get more fine grained control 🤏 Fold back to go back to a simpler representation preserving as much of the content as possible

We’re experimenting with different ways of summarising information visually. This a simple one where we get ‘named entities’, group and lay them out as a tree. (other categories can be added of course based on anything that an LLM can produce) To me at least there are couple of interesting things in this space: - interactions - pagination (done!), sorting, filtering, (re-) moving of the nodes - bidirectional connection to the source (e.g. navigating to a particular mention in the parent block,) and canvas (drag and drop of the nodes to expand on canvas)—cf. the video - multiple sources + analysis & comparison - e.g. a graph that answers the question of what are some common themes, ideas, entities in two pieces of information (e.g. a video lecture and a webpage) - tools for extending the graph - by search - by generative AI - by custom/manual annotations I would of course be very grateful for comments on any of the above 🙏 Wonderful weekend to you all 🍹

CodeParadise is a (Pharo) Smalltalk project to create web applications using Smalltalk only (and HTML/CSS 😉). A tiny Smalltalk image runs inside the browser and performs all the UI logic. Normally applications created with CodeParadise have a highly interactive character and communicate with a server environment. A new feature allows a running tiny image to be saved and restarted later as a Single Page Application. A sealed snapshot is made, meaning the connection with the server environment is removed. All code running inside the browser (in the tiny image) is saved in the snapshot as well as the current DOM. After the snapshot is restarted the application will create the same DOM structure and rehydrate the WebComponents and you'll have a running application again! For a short video see: Or go to the resulting SPA at: https://codeparadise.nl/blog-example (open the browser inspector to see all the WebComponents) Happy coding!

Hi, this week I finally managed to make a much smaller version of the fibonacci algorithm in a visual flow : What helped, is to be able to define variables inside a flow and use them in an expression, even if the variables are defined in nodes that comes after the expression node in where they are used. In this case it's an array variable node that is needed. Something that I currently am trying to accomplish is creating visual flows that are smaller and therefore hopefully clearer and more helpful in explaining algorithms. In my previous visual implementations of the Fibonacci algorithm much more nodes and connections where needed not helping in explaning the algortihm (in the thread I have shared a previous implementation). I think this new approach helps and I'll explore this further. * update * after uploading the video I got another idea that helps showing the invisible connections between the nodes: when the array/list-node elements are read or an item is added.. a small rectangle around the element now flashes 😎 .. so I've re-uploaded the video