Mehr Zeit für das, was Dir wichtig ist! #Glasfaser macht's möglich. Für schnelles Internet gibt es natürlich keine Nutzungspflicht – aber Dein Alltag wird dadurch digitaler & einfacher. Denn Glasfaser macht Schluss mit langen Ladezeiten.

Vorteile von Glasfaser gegenüber #DSL-Anschluss:
Schnellste Datenübertragung und Upload
Stabile Leitung
Nachhaltig und langlebig

Mit Glasfaser ist das Land für die Zukunft gerüstet. Und mit unserer Gigabitstrategie treiben wir den Ausbau voran.

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

#stateOfTheWorld of #lispmoo2
After getting @gnemmi and @theruran's involvement, here's what I did to implement #dot as a #DSL inside #MOO as a DSL inside #LISP so far. Basically dot is more concise than my faux-moo for the "hashtag game" morph of lispmoo2 [-world -graph -building]. Pictures, words.
Adapting this:
https://hackers.town/@theruran/113524805762331315
To:
theruran::comfy_forest:nw -- screwtape::mountain_trail;
theruran::reading_nook:se -- theruran::memsafe_workshop;

1/x :

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.

Is there such a thing as a #tester for the phone #cords that connect a #DSL #modem to the phone line.

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/

Meine DSL-Fritzbox 7490 kommt in die Jahre. Womit soll ich sie ersetzen? #FritzBox #DSL #router #wlan #mesh

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):

https://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:

- 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

#HowToThing #014 — Building a simple browser REPL UI for yesterday's Lispy S-expression mini language[1], using https://thi.ng/rdom and other usual suspects like https://thi.ng/rstream & https://thi.ng/transducers.

The language impl itself now also has local let-bindings, some more error checking, introspection and more examples of built-in functions...

Demo:
https://demo.thi.ng/umbrella/lispy-repl/

Source code:
https://github.com/thi-ng/umbrella/blob/develop/examples/lispy-repl

(The attached source code image only shows the UI/REPL parts, the language implementation can be found in the above link...)

#ThingUmbrella #TypeScript #JavaScript #Lisp #FunctionalProgramming #Reactive #UI #REPL #DSL

[1] See yesterday's toot about building/using a mini DSL:
https://mastodon.thi.ng/@toxi/111006345413482231

#HowToThing #013 — Building a toy Lisp language and interpreter using the S-expression parser from https://thi.ng/sexpr and polymorphic multiple dispatch functions via https://thi.ng/defmulti. A small language like this can be useful for DSL purposes, user programming or for just learning about interpreters. The entire setup is highly customizable (incl. support for different kinds of S-expressions, see package readme).

Even this tiny example includes the following features: variadic math ops, ability to define new symbols/variables & functions, lexical scoping, numeric & string values...

Some example invocations are included at the end...

Source code:
https://github.com/thi-ng/umbrella/blob/develop/packages/sexpr/README.md#interpreter

(Update: Minor code simplifications, updated images)