shakedown.social is one of the many independent Mastodon servers you can use to participate in the fediverse.
A community for live music fans with roots in the jam scene. Shakedown Social is run by a team of volunteers (led by @clifff and @sethadam1) and funded by donations.

Administered by:

Server stats:

261
active users

#dsl

1 post1 participant0 posts today

This #sharingsaturday I'm excited to share a new build of our #indie #roguelike Imcaving, since it now features a dialogues mechanics! Implemented as #CommonLisp #DSL, it is powerful enough to even provide dialogues with attribute rolls akin to Fallout 1/2/New Vegas.

We've also ironed out a couple of geometric bugs this week and implemented an interactive cursor indicating the tile that will be interacted upon when clicking a mouse. Moreover, @w96k continues to work on game's soundtrack.

Feel free to download the new build at awkravchuk.itch.io/imcaving#do and let us know what you think! 😊

itch.ioImcaving by Andrew, wkz, ViruScDProcedurally generated turn-based roguelike in fantasy setting

#ReleaseWednesday — Extracted & extended the LISP-like DSL from an existing #ThingUmbrella example[1] as new small package for better/direct re-use in other projects:

thi.ng/lispy

The core language is kept intentionally minimal, aimed at simple sandboxed data transformations/derivations, small code snippets/expressions in GUIs or config settings. However, the language is very easy to extend/customize with new functions or control flow constructs etc. Currently, the language is interpreted and has the following builtins (see screenshots). There's no macro support so far (and not sure if that's even desired here)...

[1] The original #HowToThing example browser REPL this was extracted from (and which has now been updated to use the new package):

demo.thi.ng/umbrella/lispy-rep

#ThingUmbrella #Lisp #DSL #FunctionalProgramming #REPL

Who in the world though it a good idea putting their custom readtables into libraries intended for outside use? I don't want your hash table syntax, I want MINE. Don't pollute the readtable and other aspects of someone else's image if you're providing a library. The library you're making should be portable and clean #CommonLisp, not some unreadable #DSL you use in your #REPL. It's fine in the REPL, but not in libraries. Keep it clean. Simple courtesy.

Not pointing fingers, but everyone doing that shall be ashamed.

I've been stuck on #ipv4 for years, as the only provider of #fibre (and before that #DSL) in our neighborhood has been #Bell #Canada. They've stubbornly refused to "get with the program", though they apparently have in their mobile infrastructure (where the IPV4 number scarcity may actually impact them).
I might just subscribe to an #ipv6 #VPN - most don't, or actively block #ipv6, but a few do. They start at just a couple of bucks a month.
cloudwards.net/best-ipv6-vpn/

Cloudwards · Best IPv6 VPN for 2024 [VPNs With IPv6 Support]hide.me is the best VPN that currently has full support for IPv6. We also like Perfect Privacy, AirVPN and OVPN. Find out why with our guide.

PyInfra demonstrates a powerful point. With Ansible if you want to feed information to Ansible, you must do through so Yaml. Yaml is fine, but PyInfra simply lets you feed information directly to it without an intermediary file format.

Why do we complicate our lives with these intermediate formats when they're often unnecessary? Wouldn't pure programming be better for the user?

I'm looking at you, OpenTofu.

Over the past few days I've been working on extending & re-packaging the procedural text generation engine from one of the old examples into a new package and also just wrote/updated documentation for its various features:

- variable definitions, optionally with multiple value choices
- cyclic & recursive variable references/expansion
- variable assignments
- dynamic, indirect variable lookups (for context specific situations)
- optional preset & custom modifiers (i.e. pointfree/concatenative application of modifier sequences)
- controlled randomness during var expansion

The new package is called: thi.ng/proctext (6.5KB incl. all deps) The text format used relies on a simple parser grammar defined and processed via thi.ng/parse. The resulting document AST is then interpreted via thi.ng/defmulti

Please see readme for notes/examples, as well as the refactored example project below. The tool is very useful for complex source code generation, but also could be useful for bots, interactive fiction etc. The generator is stateful and variable state can be optionally retained/re-used over multiple invocations. Making all modifiers async is also providing a lot of flexibility (e.g. loading external data sources, generating secondary/expanded descriptions etc.)

Demo (incl. 5 examples and can be used as playground):
demo.thi.ng/umbrella/procedura

thi.ng/proctextExtensible procedural text generation engine with dynamic, mutable state, indirection, randomizable & recursive variable expansions

Some previews of recent #ThingUmbrella updates/additions:

1) The declarative & fully typed CLI arg parser thi.ng/args now has a nice `cliApp()` wrapper (also largely declarative), supporting multiple sub-commands (with shared and command-specific args/options), automated usage generation, no-color.org support/detection. Still doing more testing with various CLI tools of mine (from which this all has been extracted), but planning to release in next couple of days...

2) People who've been following the project will know that for years I've been a big fan of Tachyons CSS[1], which is pretty much used for all ~150 examples in the repo. As nice as it is, it's also unmaintained by now and there're various more modern features missing (e.g. grids) and there're also general issues with the overall approach. Switching to Tailwind would mean having to install a whole boatload of additional tooling so is anathema and also doesn't address some of the features I've been wanting to explore: E.g. Generating entire CSS frameworks from a bunch of wildly combinatorial rules, options & lookup tables, keeping literally _everything_ customizable, combinable and purely data-driven (i.e. generated from a JSON file). Similar to Tachyons CSS, these custom generated frameworks are based on standalone CSS utility classes (hence the original particle-inspired naming). However, I'm aiming for a different usage and instead of assigning them directly to an HTML element's `class` attrib, here we can assign them to (nested) CSS selectors to define fully inlined declarations. The additional killer feature is that each of these classes can be prefixed with an arbitrary number of freely defined media queries and thus making it trivial to add additional responsive/accesible features and _without_ requiring megabytes of raw CSS to cover the combinatorial explosion!

For the past few days I've been trialling this new approach and I very much like where this is going... Take a look at the basic example in the new thi.ng/meta-css package & readme. I will also write more about this in coming days. All in all, it's another example where code generation and a domain specific language approach is super powerful again... limits of my world and such...

Also, speaking of bloatware (earlier above), the entire toolchain (incl. CLI & all dependent packages) is a mere 21KB (minified) and it already can do a ton!

#CSS#CLI#DSL

"The limits of my language mean the limits of my world" — Wittgenstein

I keep on thinking (again!) about the importance & potential of dedicated programming languages in (not just my own) generative art/design processes and want to make time to write more about it.

Example: Creating a custom DSL to describe recursive spatial tree transformations (here only 8 operators) to literally grow complex objects from a _single_ seed shape/box. These objects and their growth visualizations are a few of my fave examples from this 2013/14 research (a project to revisit):

thi.ng/morphogen

The animations are simply visualizing the resulting object of the partially transformed operator trees by artificially limiting recursion depth (increasing it over time)...

Ps. The 3.5m tall and 2.4m diameter 3D printed chandelier shown in the last image was generated with the same language & related thi.ng toolchain...

#HowToThing #026 — Shader meta-programming techniques (functional composition, higher-order functions, compile-time evaluation, dynamic code generation etc.) to generate animated plots/graphs of 16 functions (incl. dynamic grid layout generation) within a single WebGL fragment shader.

Today's key packages:

- thi.ng/shader-ast: DSL to write (fully type-checked) shaders directly in TypeScript and later compile them to GLSL, JS (and other target languages, i.e. there's partial support for Houdini VEX and [very] early stage WGSL...)
- thi.ng/shader-ast-stdlib: Collection of ~220 re-usable shader functions & configurable building blocks (incl. SDFs primitives/ops, raymarching, lighting, matrix ops, etc.)
- thi.ng/webgl-shadertoy: Minimal scaffolding for experimenting with fragment shaders (supports both normal GLSL or shader-ast flavors/compilation)

If you're new to the Shader-AST approach (highly likely!), this example will again introduce a lot of new concepts, hopefully in digestible manner! Please also always consult the package readmes (and other linked examples) for more background info... There're numerous benefits to this approach (incl. targetting different target langs and compositional & optimization aspects which are impossible to achieve (at least not elegantly) via just string concatenation/interpolation of shader code, as is much more commonplace...)

This example comes fresh off the back of yesterday's new easing function additions (by @Yura), though we're only showing a subset here...

Demo:
demo.thi.ng/umbrella/shader-as
(Check the console to view the generated GLSL shader)

Source code:
github.com/thi-ng/umbrella/tre

If you have any questions about this topic or the packages used here, please reply in thread or use the discussion forum (or issue tracker):

github.com/thi-ng/umbrella/discussions