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 https://awkravchuk.itch.io/imcaving#download and let us know what you think!
#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:
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):
https://demo.thi.ng/umbrella/lispy-repl/
#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.
Wie schön Glasfaser wird verlegt und bei mir als #DSL Kunden heißt es "Es besteht ein Problem mit der DSL-Kabelverbindung bei ca. 28 Metern." Foto vom Bagger folgt ...
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.
https://www.cloudwards.net/best-ipv6-vpn/
i wanted to make #art this sunday
#fediart #absolutelyPropietary #modems #dsl #malware #ownwork @rootcompute @mangeurdenuage @jeffcliff @fsf @rms
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.
Updated internal state handling of the https://thi.ng/parse parser generators & DSL to define parsers. Seeing a 1.2 - 1.6x speedup of parsing performance in example projects (see project readme for links), especially for larger inputs...
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: https://thi.ng/proctext (6.5KB incl. all deps) The text format used relies on a simple parser grammar defined and processed via https://thi.ng/parse. The resulting document AST is then interpreted via https://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):
https://demo.thi.ng/umbrella/procedural-text/
Jenny’s Daily Drivers: Damn Small Linux 2024 - There was a time when the gulf between a new computer and one a decade or more old... - https://hackaday.com/2024/03/05/jennys-daily-drivers-damn-small-linux-2024/ #minimalistdistro #hackadaycolumns #damnsmalllinux #computerhacks #dsl
I am considering shifting over from #Rogers #HFC to #Bell #XGSPON
The #PPPoE #ONT noise has given me pause.
I get that #DSL adopted PPPoE because circuit switching underlay (*cough* ATM). It sort of made sense then. Barely.
But what is the justification for continuing PPPoE on *PON networks?
It seems like extra equipment scaling cost & complexity to me.
Some previews of recent #ThingUmbrella updates/additions:
1) The declarative & fully typed CLI arg parser https://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, https://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 https://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!
"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):
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:
- https://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...)
- https://thi.ng/shader-ast-stdlib: Collection of ~220 re-usable shader functions & configurable building blocks (incl. SDFs primitives/ops, raymarching, lighting, matrix ops, etc.)
- https://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:
https://demo.thi.ng/umbrella/shader-ast-easings/
(Check the console to view the generated GLSL shader)
Source code:
https://github.com/thi-ng/umbrella/tree/develop/examples/shader-ast-easings/src/index.ts
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
Moin. Mal ne Frage an euch: weiß jemand wie ich mehrere #DSL Anschlüsse bündeln kann? Es geht darum die #Bandbreite zwei vernetzter #Firmenstandorte zu erhöhen. Danke
Just found out Jetbrains has developed a language workbench: https://www.jetbrains.com/mps/concepts/, to create your own DSL. I saw it in the academic world but didn't expect it in my Jetbrains Toolbox launcher. #dsl #programming #jetbrains