하지만, 이걸 위해 메일 서버를 별도로 구축하거나, 메일 클라이언트와 검색 기능 등을 별도로 코딩하기에는 아무리 AI Code Generation을 쓴다고 해도, 쓸만한 결과물이 나오기까지의 과정이 여간 쉬운 일이 아니다.
결국, 이메일과 관련된 모든 기능이 이미 있는 "MS Office"에 붙어서 바로 코딩할 수 있는 JS 프레임워크를 이용하기로 했다.
MS Outlook의 메일을 AI로 분석하는 실제 예시
// Analyze Microsoft Outlook data with ChatGPT// Require: WelsonJS framework (https://github.com/gnh1201/welsonjs)// Workflow: Microsoft Outlook -> OpenAI -> Get Responsevar Office = require("lib/msoffice");var LIE = require("lib/language-inference-engine");function main(args) { var prompt_texts = []; var keyword = "example.com"; var maxCount = 10; var previewLen = 160; console.log("Searching mails by sender OR recipient contains: '" + keyword + "'."); console.log("This test uses Restrict (Sender/To/CC/BCC) + Recipients verification."); console.log("Body preview length: " + previewLen); var outlook = new Office.Outlook(); outlook.open(); outlook.selectFolder(Office.Outlook.Folders.Inbox); var results = outlook.searchBySenderOrRecipientContains(keyword); console.log("Printing search results. (max " + maxCount + ")"); results.forEach(function (m, i) { var body = String(m.getBody() || ""); var preview = body.replace(/\r/g, "").replace(/\n+/g, " ").substr(0, previewLen); var text = "#" + String(i) + " | From: " + String(m.getSenderEmailAddress()) + " | To: " + String(m.mail.To || "") + " | Subject: " + String(m.getSubject()) + " | Received: " + String(m.getReceivedTime()); console.log(text); console.log(" Body: " + preview); // Add an email data to the prompt text context prompt_texts.push(text); // The body to reduce token usage and avoid sending overly large/sensitive content. var bodyForPrompt = body; var maxBodyLengthForPrompt = 2000; // Keep the body snippet short if (bodyForPrompt.length > maxBodyLengthForPrompt) { bodyForPrompt = bodyForPrompt.substring(0, maxBodyLengthForPrompt) + "..."; } prompt_texts.push(" Body: " + bodyForPrompt); }, maxCount); outlook.close(); // build a AI prompt text var instruction_text = "This is an email exchange between the buyer and me, and I would appreciate it if you could help me write the most appropriate reply."; prompt_texts.push(instruction_text); // complete the prompt text var prompt_text_completed = prompt_texts.join("\r\n"); //console.log(prompt_text_completed); // print all prompt text // get a response from AI var response_text = LIE.create().setProvider("openai").inference(prompt_text_completed, 0).join(' '); console.log(response_text);}exports.main = main;
실행 방법
1. CLI 사용
모든 작성 및 저장을 마친 후, 다음 명령을 통해 실행한다. (outlook_ai.js 파일로 저장했을 때.
Is there, like, a javascript library for manipulating midi files?
I was going to write a format converter in Python, but then I thought it would be a lot more useful to more organ grinders if it could run in a web page.
Webmidi js is super cool, but, like only does a small part of what i need from a midi library.
Is there, like, a javascript library for manipulating midi files?
I was going to write a format converter in Python, but then I thought it would be a lot more useful to more organ grinders if it could run in a web page.
Webmidi js is super cool, but, like only does a small part of what i need from a midi library.
This sketch also runs on #DOjS, my #p5js compatible #CreativeCoding platform for #MSDOS. Only change is that I needed to remove the SVG rendering as that is not supported.
🚩✊ Friday is Dependency Deletion Day! Today on the chopping block: rimraf (103,000,000 downloads/week). Unless your Node.js version is from the Cretaceous, rimraf delegates to fs.rm under the hood anyway, so you might as well just skip the middleman. Free your node_modules, use fs.rm!
🚩✊ Friday is Dependency Deletion Day! Today on the chopping block: rimraf (103,000,000 downloads/week). Unless your Node.js version is from the Cretaceous, rimraf delegates to fs.rm under the hood anyway, so you might as well just skip the middleman. Free your node_modules, use fs.rm!
I need to create a webapp that gets data from a csv file and stores in sqlite db, and this db data has to fill a docx template file. Which language is better for the job? #Go#Javascript or #Python ?
MiniShader is a small JS/WebGL renderer for prototyping fragment shaders locally. It provides common uniforms, up to three image/video inputs, and can export a standalone HTML page.
MiniShader is a small JS/WebGL renderer for prototyping fragment shaders locally. It provides common uniforms, up to three image/video inputs, and can export a standalone HTML page.
Dear JS ecosystem, I love you, but you have a dependency management problem when it comes to the Web, and the time has come for an intervention. — by @leaverou
Dear JS ecosystem, I love you, but you have a dependency management problem when it comes to the Web, and the time has come for an intervention. — by @leaverou
Remember the old #html , #css and #javascript badges? These came out around around 15 years ago.... I'm getting old
ALT text detailsThe html5 era badges for web technologies:
One is orange and has a 5 in the middle, reads "HTML".
Another is blue, has a 3 in the middle, reads CSS.
The last one is yellow has the letters JS in the middle, it reads "JS".
Remember the old #html , #css and #javascript badges? These came out around around 15 years ago.... I'm getting old
ALT text detailsThe html5 era badges for web technologies:
One is orange and has a 5 in the middle, reads "HTML".
Another is blue, has a 3 in the middle, reads CSS.
The last one is yellow has the letters JS in the middle, it reads "JS".
I'm Fabio, a software developer originally from #Brazil based in Toronto. I work mostly with #Ruby and #Javascript but I'm always trying new languages and stacks because why not?
I'm very much an AI skeptic – borderline hater when it comes to AI "art" – but I keep an open mind and I'm very familiar with the available tools (hence the skepticism/hate).
I also make music sometimes - mostly electronic using #Ableton, #DirtyWaveM8, #PolyendTracker and other bits and pieces, including live drums!
Instead of just passing text to an #LLM, it autonomously gathers context from linked pages and references to produce translations that actually understand what they're #translating.
Instead of just passing text to an #LLM, it autonomously gathers context from linked pages and references to produce translations that actually understand what they're #translating.
Instead of just passing text to an #LLM, it autonomously gathers context from linked pages and references to produce translations that actually understand what they're #translating.
Instead of just passing text to an #LLM, it autonomously gathers context from linked pages and references to produce translations that actually understand what they're #translating.
Instead of just passing text to an #LLM, it autonomously gathers context from linked pages and references to produce translations that actually understand what they're #translating.
Instead of just passing text to an #LLM, it autonomously gathers context from linked pages and references to produce translations that actually understand what they're #translating.
I'm thinking of learning React/NextJS/Typescript. Is this a good idea? I know HTML and CSS like the back of my hand, and half know Javascript (and PHP). I've been building websites on and off for 25 years. A year ago I started putting thought and research into creating my own CMS for the flexibility (and having a hobby project). I started learning Laravel, mostly because 10 years ago I had wanted to learn it, though I never got around to it. Plus I figured I would be able to pick it up quite easily, already having an understanding of how PHP works. But over this last year, I've not been able to engage with learning it, wondering if there is any point learning something (getting on a bit now) that still leads to a clunky PHP app that needs constant maintainence. I figure instead, I could use NextJs for the frontend, and a headless flexible open source data management / cms for the backend. I would think it would take me at least a year of learning and practice to become adequate enough. So, I'm trying to decide if this is where I should put my energy - or if there is something else I should be putting focus on, if I'm going to start properly learning something new to me.
#ReleaseThursday#OpenSourceXmas A little present (to some of you)... Been meaning to release these recent additions before the holidays, but only getting around to it now. The most important new things are these:
https://thi.ng/units now includes a Lisp-like formula DSL to combine, calculate and convert quantities and units in a much concise manner than via the normal TypeScript API (see attached examples)
https://thi.ng/pixel-io-tiff is a new package (only 2.6KB) to provide TIFF image format parsing and EXIF/GPS metadata extraction (without having to parse the image fully). Also includes format conversions for https://thi.ng/pixel buffers (grayscale 8/16bit, RGB 24/32bit), but only supports most common TIFF features (e.g. tiles, strips, uncompressed or deflate). Supports multiple sub-images... Write support will be released early next year
https://thi.ng/math now has conversions to/from fractions, using "continued fractions" for best possible precision (also includes recursion-free implementations of GCD & LCM).
https://thi.ng/binary now provides `DATAVIEW`, a JS-native DataView-like API tailored for using `Uint8Array` or vanilla JS numeric arrays (assuming the array contains u8 values) and accessors for signed/unsigned 8-64bit word sizes and little/big endian ordering.
ALT text detailsScreenshot of a section of the thi.ng/units package readme giving an overview of the new formula DSL provided. The included code examples show how to:
- compute weight in grams of A4 paper with 320 grams per square meter
- compute weight in kg of 1/2 inch thick 200x300mm glass plate
- same as previous but using the `glass` density preset
Direct link: https://github.com/thi-ng/umbrella/tree/develop/packages/units#domain-specific-language
A fun fact from the latest #CloudFlare 2025 - practically all web today is based on #JavaScript frameworks. That is, to load simple “my company is ACME WIDGETS and here’s my phone” majority of pages will first load 145 MB of advanced JavaScript libraries and then make requests to further 50 Google and Amazon trackers to report “someone saw your phone!”, wasting tons of bandwidth, electricity, memory and time.
arr.sort((a, b) => a - b); 보다 sortAsc(arr)가 낫고, sortAsc(arr) 보다 sort123(arr) 내지는 sortAbc(arr)가 낫다.
arr.sort((a, b) => a - b);
이런 코드를 마주하면 나는 보통 js 콘솔에다가
[3, 2, 1].sort((a, b) => a - b); // [1, 2, 3]
이걸 실행해서 이게 오름차순인지 내림차순인지 확인하곤 한다.
사실 자주 접하는 패턴이라 abab로 적혀있으면 바로 오름차순이라고 읽히긴 하는데 내가 제대로 읽은게 맞나 싶어서 매번 다시 확인한다.
// 오름차순으로 arr 정렬arr.sort((a, b) => a - b);
이렇게 주석으로 오름차순인지 내림차순인지 언급해주면 좀 낫긴 하지만 나는 사람에 대한 기대가 낮다.
// 오름차순으로 arr 정렬arr.sort((a, b) => b - a); // ?
원래 오름차순이었던 코드를 누가 내림차순으로 바꾸면서 주석은 안 고쳐놨을지 어떻게 아나.
누군가가 코드를 고쳐놓고 주석 또는 문서는 안 고쳐놓는 경우를 일하면서 수도없이 (오늘도) 마주했다.
이런건 주석보다는 그냥 자신의 동작을 잘 설명하는 이름이 붙은 함수를 만드는게 맞다.
// 실제 코드에서 이렇게 sort asc라고 써있으면 양반이다.// 보통 사람들은 함수명을 sortBlablaArr 따위로 적어두고// 그게 오름차순인지 내림차순인지 제 3의 기준인지 언급하지 않는다.function sortAsc(arr) { return [...arr].sort((a, b) => a - b);}
그런데 나는 sortAsc라는 이름을 보면 바로 감이 확 오지는 않고 대략 머리속에서 이런 절차를 거쳐서 코드를 읽는다.
풀어서 sort ascending
한국어로는 오름차순 정렬
점점 커지는(올라가는) 정렬이겠구나
1, 2, 3 같이 되겠네
이쯤 되면 사실 나한테는 sortAsc(arr)나 arr.sort((a, b) => a - b)나 해석하는데 오래걸리긴 매한가지다.
그나마 sortAsc(arr) 쪽은 js 콘솔을 열지 않고도 해석할 수 있다는 이점이 있긴 하다.
그래서 나는 사람들이 오름차순 정렬에는 sort123, 내림차순에는 sort321 같은 이름을 사용해줬으면 좋겠다.
앞서 언급한 다른 코드들보다 sort123(arr) 같은 코드가 내 머릿속의 해석 단계를 많이 줄여줄 수 있다.
sort 라는 앞에 단어를 붙이는게 (동어반복이라거나 해서) 부자연스러운 맥락에서 123, 321만 있으면 숫자로 시작하니까 식별자로 사용할 수 없어서 문제라면 abc, cba라는 대안(즉, sortAbc(arr), sortCba(arr))을 제시해본다.
A fun fact from the latest #CloudFlare 2025 - practically all web today is based on #JavaScript frameworks. That is, to load simple “my company is ACME WIDGETS and here’s my phone” majority of pages will first load 145 MB of advanced JavaScript libraries and then make requests to further 50 Google and Amazon trackers to report “someone saw your phone!”, wasting tons of bandwidth, electricity, memory and time.
let chars = " .:-=+*#%@"; let noise2D = makeNoise2D(42);
let out = ""; for (let y = 0; y < 80; y++) { let line = ""; for (let x = 0; x < 24; x++) { let v = noise2D(x * 0.08, y * 0.08); let n = chars.length; let idx = Math.floor((v + 1) * 0.5 * (n - 1)); idx = Math.max(0, Math.min(n - 1, idx)); line += chars[idx]; } out += line + "\n"; } document.getElementById("out").textContent = out;
It's day 19, Advent of Donations is almost over. Today's donation of $50 go to @astro, the web framework for content-driven websites. Since the beginning of the year I've built three websites using Astro, including my blog. I really love the flexibility and all the integrations.
A quick rundown on Invoker Commands by @jaffathecake
We've written about this a lot on the blog and will no doubt have more to say now that the need to polyfill this is quickly starting to fade. It's truly exciting to have a web-native API which can solve the “wire up a click to perform a task” problem. #WebDev#HTML#JavaScript
A quick rundown on Invoker Commands by @jaffathecake
We've written about this a lot on the blog and will no doubt have more to say now that the need to polyfill this is quickly starting to fade. It's truly exciting to have a web-native API which can solve the “wire up a click to perform a task” problem. #WebDev#HTML#JavaScript
I see various #JavaScript and #Dart libraries offering functions for detecting #Japanese kanji characters, but they almost always do this in a limited way that misses a huge number of characters, i.e. nothing beyond the #Unicode BMP, or even missing ranges in the BMP.
The only way to do this right is to
1. Work with codepoints, not UTF-16 code units
2. Look at the Unicode script property, which should be `Han` for kanji/hanzi
I see various #JavaScript and #Dart libraries offering functions for detecting #Japanese kanji characters, but they almost always do this in a limited way that misses a huge number of characters, i.e. nothing beyond the #Unicode BMP, or even missing ranges in the BMP.
The only way to do this right is to
1. Work with codepoints, not UTF-16 code units
2. Look at the Unicode script property, which should be `Han` for kanji/hanzi
Aeolian dune simulation (made in 2017) for #MeerMittwoch:
The images show a screenshot of the JavaScript application to create the simulation and some Houdini renders of exported height fields. The sim itself had 5 macro params to control the behavior of the interactive deposit/erosion/transportation process. It supported tileable patterns, customizable seed terrain (images) and ran realtime at ~30fps. The profile (cross-section) visualization was important because the tool was intended to create traction patterns for footwear...
ALT text detailsScreenshot showing a 2D grayscale height map of the simulated dune formation process. Below it is a cross-section profile view of the map's center row...
ALT text details3D render of a simulated dune (using the same heightmap shown in the 1st image)
ALT text details3D render of a simulated dune, showing a more classic long ripple pattern...
ALT text details3D render of a simulated dune with adjusted wind & deposition params to make the ripples wider and more sloped...
Made a small tool for converting images into pixel art that preserves features while downscaling. The key trick is in using edge detection, the first example is with it enabled, and second one is without
Made a small tool for converting images into pixel art that preserves features while downscaling. The key trick is in using edge detection, the first example is with it enabled, and second one is without
It's really depressing to see so many people and/or job ads talking about how they're using React so heavily for things that don't need React.
Why are we so committed to making things more complicated, and harder to learn, and having fewer skilled people?
And if you're talking about migrating JS frameworks on the front-end, at least *think* about HTMX/etc. for server-controlled rendering. Don't replace one bloat with another.
It's really depressing to see so many people and/or job ads talking about how they're using React so heavily for things that don't need React.
Why are we so committed to making things more complicated, and harder to learn, and having fewer skilled people?
And if you're talking about migrating JS frameworks on the front-end, at least *think* about HTMX/etc. for server-controlled rendering. Don't replace one bloat with another.
I may be a little late to the ChatGPT Plus party, but have been finding it rather effective at helping me learn #JavaScript for user interaction and making online games. I'm using it to enhance my #CSS on a variety of my personal sites, but have to stay vigilant when it makes recommendations. It has given me bad code, perpetuated poor designs and suggestions for #usability and #a11y, and makes pretty strong assumptions about how #Blind people use their devices. Helpful, but untrustworthy.
"JavaScript is an easy-to-use object scripting language designed for creating live online applications that link together objects and resources on both clients and servers."
UPDATE - It turns out this "proof of concept" was AI slop code where the AI just made a super vulnerable server instead of any exploit demo. Bc, of course it did.
Original:
There's an epic react server component RCE exploit making the rounds today.
A proof of concept just dropped. Probably wanna patch this rapidly.
Perhaps it’s time to embrace real web open standard .js files which don’t require any build steps or tooling to execute properly, all while utilizing the power combo of JSDoc + tsc to gain all of the benefits of type hints in IDEs and type checking in CI.
Perhaps it’s time to embrace real web open standard .js files which don’t require any build steps or tooling to execute properly, all while utilizing the power combo of JSDoc + tsc to gain all of the benefits of type hints in IDEs and type checking in CI.
Neither #Affinity nor #Darktable seemingly support 1D LUTs, which would have been too easy and useful for my #DigitalNegative preparation tool... Instead they both insist on using only 3D LUTs. Converting 1D to 3D takes a bit more effort, but thanks to https://thi.ng/transducers, it's still very easy...
ALT text detailsSyntax color highlighted TypeScript source code:
```
import {
cycle,
map,
normRange,
permutations,
str,
take,
transduce,
} from "@thi.ng/transducers";
// LUT size (number of samples per axis)
const N = 9;
// example curve of N samples in [0,1] range
// (the curve here is y = x^1.2, i.e. a basic darken effect)
const curve = [...map((x) => (x ** 1.2).toFixed(4), normRange(N - 1))];
// compute cartesian product to produce RGB tuples
const lut = permutations(curve, curve, curve);
// alternatively, create LUT which also converts to grayscale...
// const lut = take(N * N * N, cycle(map((x) => [x, x, x], curve)));
// convert LUT samples to .cube format
// (flip order of each tuple since red channel needs change fastest)
const cube = transduce(
map((x) => x.reverse().join(" ")),
str("\n"),
lut
);
// output LUT with header
console.log(`TITLE "example"
LUT_3D_SIZE ${N}
DOMAIN_MIN 0 0 0
DOMAIN_MAX 1 1 1
${cube}
`);
```
New research from Socket: We uncover how North Korean hackers are using npm, GitHub, and Vercel together to spread OtterCookie malware, adding 197 malicious npm packages.
These sorts of NPM worms have been around for a LONG time.
It's typically due a common practice of low 2fa opt-in on NPM accounts.
So be sure to setup NPM 2FA if you're a package maintainer do that asap!
A lesser known NPM capability is that you can disable install time scripts. This may break some packages but its worth a try to see if your projects can work with out any install scripts. 👇🏿
ALT text detailsPackage install scripts vulnerability
Disclaimer: we had been told this vulnerability would be disclosed on Monday, not Friday, so this post is a little rushed and may be edited later.
As disclosed to us in January and formally discussed in CERT vulnerability note VU#319816, it is possible for a maliciously-written npm package, when installed, to execute a script that includes itself into a new package that it then publishes to the registry, and to other packages owned by that user.
npm cannot guarantee that packages available on the registry are safe. If you see malicious code on the registry, report it to support@npmjs.com and it will be taken down.
How to protect yourself
If you are installing a package that you do not trust, you can avoid this vulnerability by running
npm install --ignore-scripts
If you wish to never run scripts at install time, you can instead run
npm config set ignore-scripts true
Either or both of these steps will prevent you from spreading a worm at install time.
If you install a package that contains malicious code and then execute it (e.g. by require()ing it into your code) it could still perform malicious actions. You should not execute any software downloaded from the Internet if you do not trust it, including software downloaded from npm.
ALT text details./is-npm-still-dangerous
Reads the data/infected-pkgs.txt
Downloads the latest package metadata for every known infected package
Downloads the current latest package.tgz
Uncompresses and scans the latest version using ./check-projects
Depending upon the scan result
./is-npm-still-dangerous
capacitor-voice-recorder-wav 6.0.3 - STILL COMPROMISED
haufe-axera-api-client 0.0.2 - STILL COMPROMISED
hyper-fullfacing 1.0.3 - STILL COMPROMISED
@ifelsedeveloper/protocol-contracts-svm-idl 0.1.2 - STILL COMPROMISED
my-saeed-lib 0.1.1 - STILL COMPROMISED
quickswap-ads-list 1.0.33 - STILL COMPROMISED
@seung-ju/react-native-action-sheet 0.2.1 - STILL COMPROMISED
tcsp 2.0.2 - STILL COMPROMISED
web-types-lit 0.1.1 - STILL COMPROMISED
web-types-lit 0.1.1 - STILL COMPROMISED
Found 9 npm-reports/npm-latest-bad.txt packages STILL compromised!
See npm-reports/npm-latest-bad.txt for full listing.
Warning - Most people probably don't need to run this. It causes a lot of NPM traffic. Warning - There's a few packages this fails to download and check (likely bc's they are hosted outside of NPMjs.org)
ALT text details./is-npm-still-dangerous
Reads the data/infected-pkgs.txt
Downloads the latest package metadata for every known infected package
Downloads the current latest package.tgz
Uncompresses and scans the latest version using ./check-projects
Depending upon the scan result
./is-npm-still-dangerous
capacitor-voice-recorder-wav 6.0.3 - STILL COMPROMISED
haufe-axera-api-client 0.0.2 - STILL COMPROMISED
hyper-fullfacing 1.0.3 - STILL COMPROMISED
@ifelsedeveloper/protocol-contracts-svm-idl 0.1.2 - STILL COMPROMISED
my-saeed-lib 0.1.1 - STILL COMPROMISED
quickswap-ads-list 1.0.33 - STILL COMPROMISED
@seung-ju/react-native-action-sheet 0.2.1 - STILL COMPROMISED
tcsp 2.0.2 - STILL COMPROMISED
web-types-lit 0.1.1 - STILL COMPROMISED
web-types-lit 0.1.1 - STILL COMPROMISED
Found 9 npm-reports/npm-latest-bad.txt packages STILL compromised!
See npm-reports/npm-latest-bad.txt for full listing.
Warning - Most people probably don't need to run this. It causes a lot of NPM traffic. Warning - There's a few packages this fails to download and check (likely bc's they are hosted outside of NPMjs.org)
New research from Socket: We uncover how North Korean hackers are using npm, GitHub, and Vercel together to spread OtterCookie malware, adding 197 malicious npm packages.
ALT text detailsSimilar Sha1-Hulud 11/24/25 Detection Tools
Links to other projects provided with no warranty express or implied.
https://github.com/TimothyMeadows/sha1hulud-scanner
https://github.com/mottibec/sha1hulud-scanner
https://github.com/gensecaihq/Shai-Hulud-2.0-Detector
https://github.com/tprinty/sha1hulud-action-detector
https://github.com/da1z/amihulud
https://github.com/bobberg/sha1-hulud-folder-checker
https://github.com/servusdei2018/sha1-halud-scan
https://github.com/kevcooper/fremkit
https://github.com/ysskrishna/shai-hulud-detector
https://github.com/Cobenian/shai-hulud-detect
GitHub Scanners
https://github.com/ysskrishna/shai-hulud-detector
panther-labs/panther-analysis#1826
I've updated my suggestions to include links and info on how to get fine grained control over the scripts your projects run at compile time.
There's two fairly interesting community projects that seem to address this part of the problem and make it possible to disable most install scripts while keeping the ones your project actually requires.
ALT text detailsSteps to take
Turn on Multi-Factor Authentication (MFA / 2FA) immediately on your NPM & GitHub accounts (and all other key infra). Change and review passwords for cloud services you use.
You probably shouldn't run any npm install or npm update commands until NPM and GitHub have official mitigations in place.
Before doing anything else you probably should check for signs of comproise. This can be done manually or using this repo or other similar scanning tools. If you DO continue working from an infected machine you risk having your personal data stolen or destroyed by this worm.
After verifying that your system has not already been compromised you can likely safely work as normal but you should avoid upgrading or installing any different package versions. Its not fully clear at the time of posting if NPM is taking down infected packages we're still finding infected packages for download on NPM at this time.
Before installing a new version of a package, you can download a .tgz archive using the command npm pack <package-name>. This does not install the package. You can then uncompress the package and check it for signs of compromise.
Consider disabling install scripts
npm install --ignore-scripts - Ignore install scripts
npm config set ignore-scripts true - Ignore install scripts user wide
"Package install scripts vulnerability" - NPM blog post from 2016 explaining worm mitigations
Consider using a tool for fine grained script management
These sorts of NPM worms have been around for a LONG time.
It's typically due a common practice of low 2fa opt-in on NPM accounts.
So be sure to setup NPM 2FA if you're a package maintainer do that asap!
A lesser known NPM capability is that you can disable install time scripts. This may break some packages but its worth a try to see if your projects can work with out any install scripts. 👇🏿
ALT text detailsPackage install scripts vulnerability
Disclaimer: we had been told this vulnerability would be disclosed on Monday, not Friday, so this post is a little rushed and may be edited later.
As disclosed to us in January and formally discussed in CERT vulnerability note VU#319816, it is possible for a maliciously-written npm package, when installed, to execute a script that includes itself into a new package that it then publishes to the registry, and to other packages owned by that user.
npm cannot guarantee that packages available on the registry are safe. If you see malicious code on the registry, report it to support@npmjs.com and it will be taken down.
How to protect yourself
If you are installing a package that you do not trust, you can avoid this vulnerability by running
npm install --ignore-scripts
If you wish to never run scripts at install time, you can instead run
npm config set ignore-scripts true
Either or both of these steps will prevent you from spreading a worm at install time.
If you install a package that contains malicious code and then execute it (e.g. by require()ing it into your code) it could still perform malicious actions. You should not execute any software downloaded from the Internet if you do not trust it, including software downloaded from npm.
Just finished landing Exit Code support. So now if more scanners are made or one of the projects gets more features you can quickly switch to whichever makes the most sense for your use case!
I literally lost a ton of sleep on this volunteer incident response work so I'm going to go touch grass for a bit.
More hacks later tonight, still got some loose ends gnawing at me lol.
At the end of scanning for obvious compromise the `check-projects` script then builds a listing of all of your dependencies and all of the versions your project files mention.
You can find that info under `reports/`
I'm currently working on improving the `check-projects` script so that it will alert you if ANY of your package.json or package-lock.json mentions a known infected package.
#ReleaseTuesday — Earlier today, I published https://thi.ng/arcball, a small new package providing an intuitive click & drag 3D camera view controller which is completely agnostic from any UI/drawing/rendering framework. The library simply provides the (quaternion) maths to translate gesture events into rotations and then computes a view matrix (presumably for WebGL/WebGPU).
There's also a small new example project to show how to use it (mouse & touch events are enabled, but zooming only works via scroll gestures on touchpad or mousewheel):
First pass is super simple and just looks for the file names & package.json signature for signs of infection anywhere in the path you tell it to search.
If it sees anything fishy it tells you where and stops until you've read the alert.
Oh and this only uses bash, sed, awk, grep, curl, and jq. So no npm, node or other big supply chains 🥴
At the end of scanning for obvious compromise the `check-projects` script then builds a listing of all of your dependencies and all of the versions your project files mention.
You can find that info under `reports/`
I'm currently working on improving the `check-projects` script so that it will alert you if ANY of your package.json or package-lock.json mentions a known infected package.
First pass is super simple and just looks for the file names & package.json signature for signs of infection anywhere in the path you tell it to search.
If it sees anything fishy it tells you where and stops until you've read the alert.
Oh and this only uses bash, sed, awk, grep, curl, and jq. So no npm, node or other big supply chains 🥴
If you're in a hurry, head on over to soatok/elliptic-to-noble and follow the instructions in the README in order to remove the elliptic package from your project and all dependencies in node_modules. Art: CMYKat Why replace the elliptic package? Yesterday, the Trail of Bits blog published an intern's post about finding cryptographic bugs in the elliptic library (a Javascript package on NPM) by using the Wycheproof.
Wow, just noticed #ThingUmbrella reached 3700 stars on GitHub — I'm celebrating... 🤩🫠
Heartfelt thanks to all of you who've been helping along the way (in any shape & form) and been supporting this work for all these years and across different programming languages/camps! Merci beaucoup!!! Esp. big Thank You's to fellow fediverse people/supporters from various stages of this project: @avi, @made, @lurvey, @alesroubicek, @brandtryan, @latrokles, @rc101, @jeffpalmer, @jack, @Yura, @danielrothaug, @computersandblues, @shiffman... (apologies if I forgot you/others here!) 🙏😍
Not counting the earlier years spent on my related toxiclibs library collection for Java/Processing (developed between ~2006-2012), the larger thi.ng project is now 14+ years old, starting with various 2D/3D geometry and dataviz-related libraries for Clojure/ClojureScript in 2011.
Since 2018 the main focus has been https://thi.ng/umbrella, a monorepo collection of (so far) 210+ #TypeScript projects/libraries. It will be 8 years old in January and covers an extremely wide spectrum of topics, use cases, data structures and techniques (take a look at the tag cloud on the https://thi.ng website or the tag browser[1] to explore the scope and related projects).
These 200+ main libraries are NOT forming a monolithic framework and can largely be used individually. However, many of these libraries are complementing each other, or are structured to be composable, expose related functionality at different levels of abstraction and/or are heavily re-use functionality to ensure high code density and small bundle sizes when building large(r) projects. 99% of the packages have NO 3rd party runtime dependencies... The umbrella meta-project also includes 185 commented standalone example projects, hundreds of code snippets in documentation and readme files, illustrating other possible usage & composition patterns.
The total code size of this project is now around 3850 source files, 140k lines of code and 71k lines of comments/docstrings. The example projects add in total another ~35k lines of code & comments. The average package readme size is 11.8KB. 99.9% of this all has been created & maintained by yours truly...
There're still so many unreleased (and useful/interesting!) parts of functionality I've been working on and still need to figure out how to best refactor and package them up (bit by bit) before releasing... we're not done just yet!
There seemingly are quite a few active users (~1.8 million of combined installs per month) and it's so pleasing to see how these tools have matured, are stable/reliable[2] and it confirms to me these efforts were all somehow worth it. Especially this year, I've also spent a lot more time myself using these packages in production, mostly for client projects, but also my own (some of which will be open sourced too). Of course, we all have our own particular likes and preferences for our own tools, but for my kind of work/workflows, #ThingUmbrella provides some of the most varied, productive, _composable_ and malleable tools I've ever used...
[2] ...even many of those packages which still manage to have a v0.x.y version number, often for years already! My release tool only creates new major versions when there're breaking changes, so if the API is already stable, the version stays at 0.x — I just need to manually bump some of them to a v1.0... 😅
If you're in a hurry, head on over to soatok/elliptic-to-noble and follow the instructions in the README in order to remove the elliptic package from your project and all dependencies in node_modules. Art: CMYKat Why replace the elliptic package? Yesterday, the Trail of Bits blog published an intern's post about finding cryptographic bugs in the elliptic library (a Javascript package on NPM) by using the Wycheproof.
#JavaScript has a `Map` class for holding key/value pairs, but it’s underused and underappreciated. If you fix the class’ limitations, you can use `Map` as a building block to create really interesting things — like a build system for a #static site.
#JavaScript has a `Map` class for holding key/value pairs, but it’s underused and underappreciated. If you fix the class’ limitations, you can use `Map` as a building block to create really interesting things — like a build system for a #static site.
By default canvas components defined via the latter two packages are defaulting to use the current `window.devicePixelRatio`, but this can now be overridden via the new `__dpr` control attribute to force a certain pixel density. For example, set it to 4 to create a 4x larger canvas in terms of pixel dimensions, but keep the apparent display size the same. Likewise, for performance reasons, it might be useful to keep the pixel density at 1 (or lower), even if the current screen would have a higher density.
More info in this readme section (the hiccup-canvas package is the shared "low-level" backend for the other two UI packages, which also have updated readmes):
Btw. There were also several other recent additions/releases, but since there're hardly ever any reactions to these announcements, I've reduced my messages about project updates posted here. Please let me know if I should change my mind... :)
Love it when a near complete project just appears out of nowhere.
"Brimstone is a JavaScript engine written from scratch in Rust, aiming to have full support for the JavaScript language.
Brimstone is a work in progress but already supports almost all of the JavaScript language (>97% of the ECMAScript language in test262). Not ready for use in production."
Love it when a near complete project just appears out of nowhere.
"Brimstone is a JavaScript engine written from scratch in Rust, aiming to have full support for the JavaScript language.
Brimstone is a work in progress but already supports almost all of the JavaScript language (>97% of the ECMAScript language in test262). Not ready for use in production."
Lion engineers have been squeezing time to make the website fancier with Astro. Early look: https://lion.js.org/next -- They also had a successful workshop open to all frontenders at ING this week. Theme was to "Make Lion Great Again". 😂
Maybe a good opportunity to illustrate the purpose of one of the more uncommon packages in #ThingUmbrella: The https://thi.ng/hex package provides hexadecimal formatters for a variety of word sizes (4-64 bits) and also a customizable hex dump facility, which is super useful for analyzing, debugging & reverse engineering binary data or file formats from within a NodeJS REPL session (my main dev env & workflow), but of course can also be used in other situations... This has already saved me countless of times...
ALT text detailsCropped screensho of a NodeJS REPL session showing an hexdump of a chunk of binary PDF data (trying to analyze why an earlier parse error occurred...)
ALT text detailsScreen recording of a user interacting with a document titled "Wordle in LibreOffice". The user clicks a button labeled "Start!", which shows a short animation of "Wordle in LibreOffice, Implemented in JavaScript". The user then inputs a number of words, starting with begin, then dozen, then raven, and finally taken. After making a new line after each word, the word gets highlighted in gray, yellow, and green, corresponding to the incorrect / misplaced / correct letters of that word. In the end, after another animation, the game displays "Well done! 4 / 6".
ALT text detailsScreen recording of a user interacting with a document titled "Wordle in LibreOffice". The user clicks a button labeled "Start!", which shows a short animation of "Wordle in LibreOffice, Implemented in JavaScript". The user then inputs a number of words, starting with begin, then dozen, then raven, and finally taken. After making a new line after each word, the word gets highlighted in gray, yellow, and green, corresponding to the incorrect / misplaced / correct letters of that word. In the end, after another animation, the game displays "Well done! 4 / 6".
ALT text detailsScreen recording of a user interacting with a document titled "Wordle in LibreOffice". The user clicks a button labeled "Start!", which shows a short animation of "Wordle in LibreOffice, Implemented in JavaScript". The user then inputs a number of words, starting with begin, then dozen, then raven, and finally taken. After making a new line after each word, the word gets highlighted in gray, yellow, and green, corresponding to the incorrect / misplaced / correct letters of that word. In the end, after another animation, the game displays "Well done! 4 / 6".
<!DOCTYPE html><html> <head> <meta charset="utf-8"> <title>Single Page Apps for GitHub Pages</title> <script type="text/javascript"> // Single Page Apps for GitHub Pages // https://github.com/rafrex/spa-github-pages // Copyright (c) 2016 Rafael Pedicini, licensed under the MIT License // ---------------------------------------------------------------------- // This script takes the current url and converts the path and query // string into just a query string, and then redirects the browser // to the new url with only a query string and hash fragment, // e.g. http://www.foo.tld/one/two?a=b&c=d#qwe, becomes // http://www.foo.tld/?p=/one/two&q=a=b~and~c=d#qwe // Note: this 404.html file must be at least 512 bytes for it to work // with Internet Explorer (it is currently > 512 bytes) // If you're creating a Project Pages site and NOT using a custom domain, // then set segmentCount to 1 (enterprise users may need to set it to > 1). // This way the code will only replace the route part of the path, and not // the real directory in which the app resides, for example: // https://username.github.io/repo-name/one/two?a=b&c=d#qwe becomes // https://username.github.io/repo-name/?p=/one/two&q=a=b~and~c=d#qwe // Otherwise, leave segmentCount as 0. var segmentCount = 0; var l = window.location; l.replace( l.protocol + '//' + l.hostname + (l.port ? ':' + l.port : '') + l.pathname.split('/').slice(0, 1 + segmentCount).join('/') + '/?p=/' + l.pathname.slice(1).split('/').slice(segmentCount).join('/').replace(/&/g, '~and~') + (l.search ? '&q=' + l.search.slice(1).replace(/&/g, '~and~') : '') + l.hash ); </script> </head> <body> </body></html>
Anyone who is an expert or has expertise in website coding here? How can I make my Ghost CMS with the Casper theme have a toggle for switching between dark and light themes? Dark should be the default. Alternatively, is there an option to include automatic dark/light switching based on the device or browser theme? I need help.
Tags are sets. Many apps support tagging of content, but most of them (incl. Mastodon) treat tags only as singular/isolated topic filters, akin to a flat folder-based approach. But tagging can be so, so much more powerful when treating tags as sets and offering users the possibility to combine and query tagged content as sets (think Venn diagrams), i.e. allowing tags to be combined using AND/OR/NOT aka intersection/union/difference operations...
Below is a simple query engine to do just that in ~40 lines of code (sans comments), incl. using an extensible interpreter for a simple Lisp-like S-Expression language to define arbitrarily complex nested tag queries (the code is actually lifted & simplified from my personal knowledge graph tooling, also talked about here recently[1]...)
...would select all items which have been tagged with `Alps` OR `PNW`, AND have at least one of the two photography tags given, but have NOT the `Monochrome` tag.
Whilst this syntax is probably alien-looking to the average user, it'd would be fairly straightforward to create visual/structural UIs for defining such queries (over the past 20 years I've done that myself several times already), heck even a SLM (small language model) could be used to translate natural language into such query expressions — what matters here is the widespread lack of treating tags this way in terms of conceptual/data modeling in most applications. Imagine being able to use hashtags this way on Mastodon to assemble personalized timelines (and extend the system to not just deal with hashtags, but other post metadata/provenance too)...
The code example illustrates how, with the right tools, such features are actually not hard to implement (or to integrate into existing apps). The example uses the following #ThingUmbrella packages for its key functionality:
arr.sort((a, b) => a - b); 보다 sortAsc(arr)가 낫고, sortAsc(arr) 보다 sort123(arr) 내지는 sortAbc(arr)가 낫다.
arr.sort((a, b) => a - b);
이런 코드를 마주하면 나는 보통 js 콘솔에다가
[3, 2, 1].sort((a, b) => a - b); // [1, 2, 3]
이걸 실행해서 이게 오름차순인지 내림차순인지 확인하곤 한다.
사실 자주 접하는 패턴이라 abab로 적혀있으면 바로 오름차순이라고 읽히긴 하는데 내가 제대로 읽은게 맞나 싶어서 매번 다시 확인한다.
// 오름차순으로 arr 정렬arr.sort((a, b) => a - b);
이렇게 주석으로 오름차순인지 내림차순인지 언급해주면 좀 낫긴 하지만 나는 사람에 대한 기대가 낮다.
// 오름차순으로 arr 정렬arr.sort((a, b) => b - a); // ?
원래 오름차순이었던 코드를 누가 내림차순으로 바꾸면서 주석은 안 고쳐놨을지 어떻게 아나.
누군가가 코드를 고쳐놓고 주석 또는 문서는 안 고쳐놓는 경우를 일하면서 수도없이 (오늘도) 마주했다.
이런건 주석보다는 그냥 자신의 동작을 잘 설명하는 이름이 붙은 함수를 만드는게 맞다.
// 실제 코드에서 이렇게 sort asc라고 써있으면 양반이다.// 보통 사람들은 함수명을 sortBlablaArr 따위로 적어두고// 그게 오름차순인지 내림차순인지 제 3의 기준인지 언급하지 않는다.function sortAsc(arr) { return [...arr].sort((a, b) => a - b);}
그런데 나는 sortAsc라는 이름을 보면 바로 감이 확 오지는 않고 대략 머리속에서 이런 절차를 거쳐서 코드를 읽는다.
풀어서 sort ascending
한국어로는 오름차순 정렬
점점 커지는(올라가는) 정렬이겠구나
1, 2, 3 같이 되겠네
이쯤 되면 사실 나한테는 sortAsc(arr)나 arr.sort((a, b) => a - b)나 해석하는데 오래걸리긴 매한가지다.
그나마 sortAsc(arr) 쪽은 js 콘솔을 열지 않고도 해석할 수 있다는 이점이 있긴 하다.
그래서 나는 사람들이 오름차순 정렬에는 sort123, 내림차순에는 sort321 같은 이름을 사용해줬으면 좋겠다.
앞서 언급한 다른 코드들보다 sort123(arr) 같은 코드가 내 머릿속의 해석 단계를 많이 줄여줄 수 있다.
sort 라는 앞에 단어를 붙이는게 (동어반복이라거나 해서) 부자연스러운 맥락에서 123, 321만 있으면 숫자로 시작하니까 식별자로 사용할 수 없어서 문제라면 abc, cba라는 대안(즉, sortAbc(arr), sortCba(arr))을 제시해본다.
arr.sort((a, b) => a - b); 보다 sortAsc(arr)가 낫고, sortAsc(arr) 보다 sort123(arr) 내지는 sortAbc(arr)가 낫다.
arr.sort((a, b) => a - b);
이런 코드를 마주하면 나는 보통 js 콘솔에다가
[3, 2, 1].sort((a, b) => a - b); // [1, 2, 3]
이걸 실행해서 이게 오름차순인지 내림차순인지 확인하곤 한다.
사실 자주 접하는 패턴이라 abab로 적혀있으면 바로 오름차순이라고 읽히긴 하는데 내가 제대로 읽은게 맞나 싶어서 매번 다시 확인한다.
// 오름차순으로 arr 정렬arr.sort((a, b) => a - b);
이렇게 주석으로 오름차순인지 내림차순인지 언급해주면 좀 낫긴 하지만 나는 사람에 대한 기대가 낮다.
// 오름차순으로 arr 정렬arr.sort((a, b) => b - a); // ?
원래 오름차순이었던 코드를 누가 내림차순으로 바꾸면서 주석은 안 고쳐놨을지 어떻게 아나.
누군가가 코드를 고쳐놓고 주석 또는 문서는 안 고쳐놓는 경우를 일하면서 수도없이 (오늘도) 마주했다.
이런건 주석보다는 그냥 자신의 동작을 잘 설명하는 이름이 붙은 함수를 만드는게 맞다.
// 실제 코드에서 이렇게 sort asc라고 써있으면 양반이다.// 보통 사람들은 함수명을 sortBlablaArr 따위로 적어두고// 그게 오름차순인지 내림차순인지 제 3의 기준인지 언급하지 않는다.function sortAsc(arr) { return [...arr].sort((a, b) => a - b);}
그런데 나는 sortAsc라는 이름을 보면 바로 감이 확 오지는 않고 대략 머리속에서 이런 절차를 거쳐서 코드를 읽는다.
풀어서 sort ascending
한국어로는 오름차순 정렬
점점 커지는(올라가는) 정렬이겠구나
1, 2, 3 같이 되겠네
이쯤 되면 사실 나한테는 sortAsc(arr)나 arr.sort((a, b) => a - b)나 해석하는데 오래걸리긴 매한가지다.
그나마 sortAsc(arr) 쪽은 js 콘솔을 열지 않고도 해석할 수 있다는 이점이 있긴 하다.
그래서 나는 사람들이 오름차순 정렬에는 sort123, 내림차순에는 sort321 같은 이름을 사용해줬으면 좋겠다.
앞서 언급한 다른 코드들보다 sort123(arr) 같은 코드가 내 머릿속의 해석 단계를 많이 줄여줄 수 있다.
sort 라는 앞에 단어를 붙이는게 (동어반복이라거나 해서) 부자연스러운 맥락에서 123, 321만 있으면 숫자로 시작하니까 식별자로 사용할 수 없어서 문제라면 abc, cba라는 대안(즉, sortAbc(arr), sortCba(arr))을 제시해본다.
Been updating my personal Mastodon tooling to download and convert my bookmarked toots. Here's how little code is needed to download a single message and convert its HTML content into Markdown, all using these #ThingUmbrella packages:
- https://thi.ng/hiccup: Interop data format (i.e. just nested JS arrays) to encode hierarchical documents - https://thi.ng/hiccup-html-parse: Parses HTML into hiccup format - https://thi.ng/hiccup-markdown: Serialize hiccup to Markdown (also includes a Markdown parser to hiccup, but not used here) - https://thi.ng/zipper: Functional tree editing, manipulation & navigation (here to clean/transform the parsed HTML document)
ALT text detailsSyntax colored TypeScript source code:
import { parseHtml } from "@thi.ng/hiccup-html-parse";
import { serialize } from "@thi.ng/hiccup-markdown";
import { arrayZipper, type Location } from "@thi.ng/zipper";
// load a Mastodon status via API
const res = await (
await fetch("https://mastodon.thi.ng/api/v1/statuses/115464108396925195")
).json();
// parse HTML content into thing/hiccup format (nested JS arrays)
const parsed = parseHtml(res.content, {
whitespace: true,
ignoreAttribs: ["class"],
}).result!;
// structure of parsed example:
// [["p", {}, "text"], ["p", {}, ...], ...]
// recursively traverse result document/array using thi.ng/zipper
// and replace all <span> elements with their raw text body
let loc: Location<any> | undefined = arrayZipper(parsed);
while (loc) {
loc = loc.next;
if (Array.isArray(loc?.node) && loc?.node[0] == "span")
loc = loc.replace(loc.node[2]);
if (loc?.next == null) break;
}
// serialize hiccup to markdown
console. log(serialize(loc?.root, null));
/*
Result (in markdown format), omitted here due to alt text limits
*/
Some details about the recently updated/fixed https://thi.ng/color package: The color scheme creation strategy functions (analog/complementary/triadic/tetradic/monochrome etc.) are all accepting base colors in any format now, but do their computation and provide results in LCH space only. I've updated/extended the readme with some basic code examples (incl. result swatches) how to use these functions — something I thought I did already 3 years ago, but obviously didn't... mea culpa! 😇
Note: The package also provides more powerful declarative, parametric approaches to color scheme generation (see 2nd image, link in alt text), plus there's also https://thi.ng/color-palettes (3rd image) which provides 255 manually created palettes (image based & curated by yours truly, used for many of own art projects...) and includes composable query operators to select palettes based on different criteria...
ALT text detailsScreenshot of excerpt of the thi.ng/color package readme about declarative/parametric color scheme generation. Direct link to relevant section: https://github.com/thi-ng/umbrella/blob/develop/packages/color/README.md#color-theme-generation
ALT text detailsScreenshot of excerpt of the thi.ng/color package readme discussing color scheme strategies. Direct link to relevant section: https://github.com/thi-ng/umbrella/blob/develop/packages/color/README.md#color-theme-strategies
ALT text detailsScreenshot of excerpt of the thi.ng/color-palettes package readme showing swatches of the most recently added themes...
An update: After several failed publish attempts, more searching, (re)reading and experimenting for the past 4 hours, I've now figured out a solution using #NPM granular access tokens... But to summarize & document the issues, in case someone else encounters the same pain points:
1) There seems to be a new incompatibility between the NPM auth changes and running `yarn npm publish --access public`. After working successfully for the past 8 years, that command now gives me 404, even after re-authenticating. It just doesn't seem to pick up the auth token configured in `$HOME/.npmrc`. As result I've now switched all my publish commands to just be `npm publish --access public`. That seems to work!
2) The wording about the 50 package limit on the NPM auth token docs is very confusing: "Each token can access up to 50 organizations, and up to either 50 packages, 50 scopes, or a combination of 50 packages and scopes." As written, this reads like these limits are omnipresent for each token, but in fact one can also create tokens which can access ALL packages under your control. The 50 limit only seems to apply when creating token which is only allowed a subset...
How does the semantic html community feel about using the <details> element to “expand” into a form submission confirmation, when submitting “dangerous” operations, instead of a <dialog>? Notably, the thing I’m working on is currently fully JS-optional so far, and I would like to keep it that way.
EDIT: Oh it looks like <button> has command and commandfor, which can open a <dialog> now.
EDIT2: oops, but it's not baseline yet, and won't be for a while. It just released in preview for Safari and Firefox. ~sigh~
»Math.random() is not so random — The Illusion of Randomness in JavaScript: Don’t Trust Math.random() - Uncovering the Hidden Predictability of Random Numbers.«
In some applications random numbers are very useful but not unique and therefore you should consider where to use it. In this regard, there are for example, UUID v4 or Nano ID and the same.
Fedify is an #ActivityPub server framework in #TypeScript & #JavaScript. It aims to eliminate the complexity and redundant boilerplate code when building a federated server app, so that you can focus on your business logic and user experience.
The key features it provides currently are:
Type-safe objects for Activity Vocabulary (including some vendor-specific extensions)
Published another couple of new versions of https://thi.ng/genart-api, mainly involving updates to the Layer (layer.com) platform adapter, adding config options and minor quality of life improvements (e.g. handling of private [aka artist-only] params)
I also updated the readme, clarifying the current versioning scheme: For ease of use and to avoid guess work about compatibility, currently all packages in this repo are published using a shared version identifier. With the release of v1.0.0, this will switch to independent semantic versioning, with support package versions aligned to the major versions of the main API.
After over a year of development, dogfooding it and using it successfully without any friction for already a dozen art pieces/projects, I'd actually consider the main API to be pretty much v1.0.0 already (even though it's current v0.33.0). So the switch will happen soon!
If you've have any issues or feature requests, please file them via the issue tracker (or write back here to discuss)! Thanks! :)
For those who wanted to see the code behind my CSS-only magical sticky auto-expanding sidebar nav in action, I've put together a little CodePen for you! I've narrowed down the relevant code to just what's needed to get this to work, with some very minimal JavaScript to improve the accessibility of it! I've even left you a little challenge in there for you, let me see how you accomplish it!
Exciting news for #Fedify developers! We've just landed a major milestone for Fedify 2.0—the #CLI now runs natively on #Node.js and #Bun, not just #Deno (#456). If you install @fedify/cli@2.0.0-dev.1761 from npm, you'll get actual JavaScript that executes directly in your runtime, no more pre-compiled binaries from deno compile. This is part of our broader transition to Optique, a new cross-runtime CLI framework we've developed specifically for Fedify's needs (#374).
This change means a more natural development experience regardless of your #JavaScript runtime preference. Node.js developers can now run the CLI tools directly through their familiar ecosystem, and the same goes for Bun users. While Fedify 2.0 isn't released yet, we're excited to share this progress with the community—feel free to try out the dev version and let us know how it works for you!
»HTML’s Best Kept Secret — The <output> Tag: Every developer knows <input>. It’s the workhorse of the web. But <output>? Most have never touched it. Some don’t even know it exists. […]« — by @denodell
You never stop learning and you can't know everything about as a WebDev. Nice to see how you can use the HTML interface actiev.
🚀 Socket now integrates with Bun 1.3’s new Security Scanner API! @bunjavascript users can now protect their projects from malicious packages, typosquatting, & other supply chain attacks. Great to see Bun moving so quickly to protect developers at the package manager level with this new API!
🚀 Socket now integrates with Bun 1.3’s new Security Scanner API! @bunjavascript users can now protect their projects from malicious packages, typosquatting, & other supply chain attacks. Great to see Bun moving so quickly to protect developers at the package manager level with this new API!
ALT text detailsscreenshot of an email that clearly says it's from support@npmjs.com, a legitimate email address belonging to the NPM support team. Fastmail has flagged it as suspicious, and that it might be a phishing attempt. The email seems to be about some "security improvements".
I am currently looking for a new #remote#job and maybe #FediHire can help me with that.
I am a #Frontend#Web#Developer based in Germany (CET) with over 10 years of experience creating complex web applications, websites and design systems in interdisciplinary teams.
I am currently looking for a new #remote#job and maybe #FediHire can help me with that.
I am a #Frontend#Web#Developer based in Germany (CET) with over 10 years of experience creating complex web applications, websites and design systems in interdisciplinary teams.
I am currently looking for a new #remote#job and maybe #FediHire can help me with that.
I am a #Frontend#Web#Developer based in Germany (CET) with over 10 years of experience creating complex web applications, websites and design systems in interdisciplinary teams.
Exciting news for #Fedify developers! We've just landed a major milestone for Fedify 2.0—the #CLI now runs natively on #Node.js and #Bun, not just #Deno (#456). If you install @fedify/cli@2.0.0-dev.1761 from npm, you'll get actual JavaScript that executes directly in your runtime, no more pre-compiled binaries from deno compile. This is part of our broader transition to Optique, a new cross-runtime CLI framework we've developed specifically for Fedify's needs (#374).
This change means a more natural development experience regardless of your #JavaScript runtime preference. Node.js developers can now run the CLI tools directly through their familiar ecosystem, and the same goes for Bun users. While Fedify 2.0 isn't released yet, we're excited to share this progress with the community—feel free to try out the dev version and let us know how it works for you!
- (Art) platform adapters can now have an optional `.configure({...})` method to customize platform-specific behaviors. To ensure future portability of your artwork (between different art platforms), calls to this method should be done from outside the artwork, i.e. via an additional `<script>` in the HTML wrapper. - Of the provided platform adapters, so far only the Layer adapter supports any options, but I'm also working on a new one for my website which will require other options and there are more use cases for which this will come in handy without adding any complexity to the overall system... - Updated param change handling in the Layer platform adapter, which now supports auto-reload for params whose update behavior has been set to `reload`. More info here: https://docs.thi.ng/genart-api/adapter-layer/#parameter-update-behavior
Exciting news for #Fedify developers! We've just landed a major milestone for Fedify 2.0—the #CLI now runs natively on #Node.js and #Bun, not just #Deno (#456). If you install @fedify/cli@2.0.0-dev.1761 from npm, you'll get actual JavaScript that executes directly in your runtime, no more pre-compiled binaries from deno compile. This is part of our broader transition to Optique, a new cross-runtime CLI framework we've developed specifically for Fedify's needs (#374).
This change means a more natural development experience regardless of your #JavaScript runtime preference. Node.js developers can now run the CLI tools directly through their familiar ecosystem, and the same goes for Bun users. While Fedify 2.0 isn't released yet, we're excited to share this progress with the community—feel free to try out the dev version and let us know how it works for you!
Exciting news for #Fedify developers! We've just landed a major milestone for Fedify 2.0—the #CLI now runs natively on #Node.js and #Bun, not just #Deno (#456). If you install @fedify/cli@2.0.0-dev.1761 from npm, you'll get actual JavaScript that executes directly in your runtime, no more pre-compiled binaries from deno compile. This is part of our broader transition to Optique, a new cross-runtime CLI framework we've developed specifically for Fedify's needs (#374).
This change means a more natural development experience regardless of your #JavaScript runtime preference. Node.js developers can now run the CLI tools directly through their familiar ecosystem, and the same goes for Bun users. While Fedify 2.0 isn't released yet, we're excited to share this progress with the community—feel free to try out the dev version and let us know how it works for you!
Exciting news for #Fedify developers! We've just landed a major milestone for Fedify 2.0—the #CLI now runs natively on #Node.js and #Bun, not just #Deno (#456). If you install @fedify/cli@2.0.0-dev.1761 from npm, you'll get actual JavaScript that executes directly in your runtime, no more pre-compiled binaries from deno compile. This is part of our broader transition to Optique, a new cross-runtime CLI framework we've developed specifically for Fedify's needs (#374).
This change means a more natural development experience regardless of your #JavaScript runtime preference. Node.js developers can now run the CLI tools directly through their familiar ecosystem, and the same goes for Bun users. While Fedify 2.0 isn't released yet, we're excited to share this progress with the community—feel free to try out the dev version and let us know how it works for you!
Exciting news for #Fedify developers! We've just landed a major milestone for Fedify 2.0—the #CLI now runs natively on #Node.js and #Bun, not just #Deno (#456). If you install @fedify/cli@2.0.0-dev.1761 from npm, you'll get actual JavaScript that executes directly in your runtime, no more pre-compiled binaries from deno compile. This is part of our broader transition to Optique, a new cross-runtime CLI framework we've developed specifically for Fedify's needs (#374).
This change means a more natural development experience regardless of your #JavaScript runtime preference. Node.js developers can now run the CLI tools directly through their familiar ecosystem, and the same goes for Bun users. While Fedify 2.0 isn't released yet, we're excited to share this progress with the community—feel free to try out the dev version and let us know how it works for you!
Exciting news for #Fedify developers! We've just landed a major milestone for Fedify 2.0—the #CLI now runs natively on #Node.js and #Bun, not just #Deno (#456). If you install @fedify/cli@2.0.0-dev.1761 from npm, you'll get actual JavaScript that executes directly in your runtime, no more pre-compiled binaries from deno compile. This is part of our broader transition to Optique, a new cross-runtime CLI framework we've developed specifically for Fedify's needs (#374).
This change means a more natural development experience regardless of your #JavaScript runtime preference. Node.js developers can now run the CLI tools directly through their familiar ecosystem, and the same goes for Bun users. While Fedify 2.0 isn't released yet, we're excited to share this progress with the community—feel free to try out the dev version and let us know how it works for you!
Exciting news for #Fedify developers! We've just landed a major milestone for Fedify 2.0—the #CLI now runs natively on #Node.js and #Bun, not just #Deno (#456). If you install @fedify/cli@2.0.0-dev.1761 from npm, you'll get actual JavaScript that executes directly in your runtime, no more pre-compiled binaries from deno compile. This is part of our broader transition to Optique, a new cross-runtime CLI framework we've developed specifically for Fedify's needs (#374).
This change means a more natural development experience regardless of your #JavaScript runtime preference. Node.js developers can now run the CLI tools directly through their familiar ecosystem, and the same goes for Bun users. While Fedify 2.0 isn't released yet, we're excited to share this progress with the community—feel free to try out the dev version and let us know how it works for you!
Exciting news for #Fedify developers! We've just landed a major milestone for Fedify 2.0—the #CLI now runs natively on #Node.js and #Bun, not just #Deno (#456). If you install @fedify/cli@2.0.0-dev.1761 from npm, you'll get actual JavaScript that executes directly in your runtime, no more pre-compiled binaries from deno compile. This is part of our broader transition to Optique, a new cross-runtime CLI framework we've developed specifically for Fedify's needs (#374).
This change means a more natural development experience regardless of your #JavaScript runtime preference. Node.js developers can now run the CLI tools directly through their familiar ecosystem, and the same goes for Bun users. While Fedify 2.0 isn't released yet, we're excited to share this progress with the community—feel free to try out the dev version and let us know how it works for you!
Exciting news for #Fedify developers! We've just landed a major milestone for Fedify 2.0—the #CLI now runs natively on #Node.js and #Bun, not just #Deno (#456). If you install @fedify/cli@2.0.0-dev.1761 from npm, you'll get actual JavaScript that executes directly in your runtime, no more pre-compiled binaries from deno compile. This is part of our broader transition to Optique, a new cross-runtime CLI framework we've developed specifically for Fedify's needs (#374).
This change means a more natural development experience regardless of your #JavaScript runtime preference. Node.js developers can now run the CLI tools directly through their familiar ecosystem, and the same goes for Bun users. While Fedify 2.0 isn't released yet, we're excited to share this progress with the community—feel free to try out the dev version and let us know how it works for you!
Exciting news for #Fedify developers! We've just landed a major milestone for Fedify 2.0—the #CLI now runs natively on #Node.js and #Bun, not just #Deno (#456). If you install @fedify/cli@2.0.0-dev.1761 from npm, you'll get actual JavaScript that executes directly in your runtime, no more pre-compiled binaries from deno compile. This is part of our broader transition to Optique, a new cross-runtime CLI framework we've developed specifically for Fedify's needs (#374).
This change means a more natural development experience regardless of your #JavaScript runtime preference. Node.js developers can now run the CLI tools directly through their familiar ecosystem, and the same goes for Bun users. While Fedify 2.0 isn't released yet, we're excited to share this progress with the community—feel free to try out the dev version and let us know how it works for you!
Exciting news for #Fedify developers! We've just landed a major milestone for Fedify 2.0—the #CLI now runs natively on #Node.js and #Bun, not just #Deno (#456). If you install @fedify/cli@2.0.0-dev.1761 from npm, you'll get actual JavaScript that executes directly in your runtime, no more pre-compiled binaries from deno compile. This is part of our broader transition to Optique, a new cross-runtime CLI framework we've developed specifically for Fedify's needs (#374).
This change means a more natural development experience regardless of your #JavaScript runtime preference. Node.js developers can now run the CLI tools directly through their familiar ecosystem, and the same goes for Bun users. While Fedify 2.0 isn't released yet, we're excited to share this progress with the community—feel free to try out the dev version and let us know how it works for you!
Exciting news for #Fedify developers! We've just landed a major milestone for Fedify 2.0—the #CLI now runs natively on #Node.js and #Bun, not just #Deno (#456). If you install @fedify/cli@2.0.0-dev.1761 from npm, you'll get actual JavaScript that executes directly in your runtime, no more pre-compiled binaries from deno compile. This is part of our broader transition to Optique, a new cross-runtime CLI framework we've developed specifically for Fedify's needs (#374).
This change means a more natural development experience regardless of your #JavaScript runtime preference. Node.js developers can now run the CLI tools directly through their familiar ecosystem, and the same goes for Bun users. While Fedify 2.0 isn't released yet, we're excited to share this progress with the community—feel free to try out the dev version and let us know how it works for you!
okay i've polished up my FediTag javascript which embeds a feed of Mastodon posts from one account using a particular hashtag on a website or page. you can find it on github https://github.com/Enichan/feditag
okay i've polished up my FediTag javascript which embeds a feed of Mastodon posts from one account using a particular hashtag on a website or page. you can find it on github https://github.com/Enichan/feditag
Been a four months since I worked on Zorn, a video player for Astro. Buttons and menus in v0.7, which isn't even published yet, already need to be rewritten, and thought out again.
Along with that, I need to also focus on making the player rely on JavaScript less during the development of v0.7.
The fallback to native player function is working quite well still, which I'm happy about. (Video Below)
ALT text detailsFallback function for Zorn Player, it is triggered if JavaScript is not enabled, showing a message that will show the native player if clicked on.
Just pushed an update for https://thi.ng/genart-api (v0.29.0) which now supports dynamic switching of time providers. This is useful for situations where you want to switch from realtime animation to offline-based timing, e.g. to export high-resolution image sequences and give the browser time to grab & encode each frame and reduce related memory pressure...
For example, your animation loop can now have something like this below to switch time providers based on a certain start frame for recording:
``` $genart.setUpdate((time, frame) => { if (frame === 1000) { // switch to non-realtime animation: // wait 250ms between frames w/ 60 fps reference frame rate // start frame for new time provider is current frame + 1 $genart.setTimeProvider( $genart.time.offline(250, 60, frame + 1) ); } // actual animation logic // ... return true; }); ```
The quick and dirty #PWA that serves as my timer app for talks is 260 LOC JS (excluding the auto-generated service worker). This is simultaneously not much and quite a lot. But it would be SO MUCH MORE without the Temporal and Intl APIs! Truly game-changing additions to #JavaScript!
The quick and dirty #PWA that serves as my timer app for talks is 260 LOC JS (excluding the auto-generated service worker). This is simultaneously not much and quite a lot. But it would be SO MUCH MORE without the Temporal and Intl APIs! Truly game-changing additions to #JavaScript!
#ReleaseFriday — New version 3.1.0 of the recently talked about https://thi.ng/args package, a declarative & functional CLI argument parser & app framework. I updated the arg specifications to be fully self-describing & serializable (with minor exceptions), and streamlined the API for factory functions to define the specs.
Why is this useful? For example, now I can (already have!) implemented a CLI as separate short-lived client/process which only acts as RPC frontend/proxy for the actual CLI commands defined & executed in a long running app server, which is heavily based on a plugin architecture. Each plugin can contribute any number of CLI commands, each with its own set of args/options... When the CLI client app is launched, it first retrieves a list of these registered commands and all their options from the server, then uses the https://thi.ng/args CLI framework to select the right command, validate its options or display formatted usage info. If all is ok, the command is then triggered via an HTTP request to the app server, executes there and the command's log messages are send back as response...
ALT text detailsBlock diagram giving a highlevel overview of a software architecture consisting of: app server, router, CLI and a number of plugins. These app component interact with each other via registrations and delegations. A separate box "CLI RPC" relates to a separate client app which only interacts with the app server and is used as remote frontend for invoking commands inside the (much longer running) main app.
Finally got around documenting a little more the small CLI app "framework" I've been using for almost a dozen projects now (incl. several work projects). The package in question is now already 3 years old (https://thi.ng/args), but I've only just managed now to add a basic, commented usage example for this `cliApp()` feature to the readme:
Also part of this: I've refactored a few other projects to simplify their CLI handling using this `cliApp()` wrapper (project links are in the above readme, in case you'd like to see more advanced/realworld uses...) One of the (non-public) work projects ended up consisting of up to a dozen sub-commands and I found this declarative and modular setup to be very, very helpful (and elegant)...
now that my Big Project™ for the year has shipped and is wrapping up, i will be enjoying some relative down time at work, in which i’d like to spend time topping up my waning modern web dev knowledge.
💡i am looking for recommendations on good online courses to bridge my knowledge gap in latest (not trendiest) CSS and JS practices. i have a few already queued up, but this will help me prioritize.
A grumpy ItSec guy walks through the office when he overhears an exchange of words.
devops0: Two containers went rogue last night and starved the whole host. devops1: What are we supposed to do?
ItSec (walking by): Set limits. It's not rocket science. Docker exposes cgroup controls for CPU, memory, I/O and PIDs. Use them.
The point is: availability is part of security too. Linux control groups allow you to cap, isolate and observe resource usage, which is exactly how Docker enforces container limits for CPU, memory, block I/O and process counts [1]. Let's make it tangible with a small lab. We'll spin a container, install stress-ng, and watch limits in action.
# On the Docker host docker run -itd --name ubuntu-limits ubuntu:22.04 docker exec -it ubuntu-limits bash
# For my host nproc returns 4 stress-ng --cpu 4 --cpu-load 100 --timeout 30s
In another terminal, watch usage from the host.
docker stats
Now clamp CPU for the running container and see the throttle take effect.
docker update ubuntu-limits --cpus=1 docker stats
The --cpus flag is a wrapper over the Linux CFS period/quota; --cpus=1 caps the container at roughly one core worth of time on a multi‑core host.
Memory limits are similar. First tighten RAM and swap, then try to over‑allocate in the container.
# On the host docker update ubuntu-limits --memory=128m --memory-swap=256m docker stats
# Inside the container: stays under the cap stress-ng --vm 1 --vm-bytes 100M --timeout 30s --vm-keep
# Inside the container: tries to exceed; you may see reclaim/pressure instead of success stress-ng --vm 1 --vm-bytes 300M --timeout 30s --vm-keep
A few memory details matter. --memory is the hard ceiling; --memory-swap controls total RAM+swap available. Setting swap equal to memory disables swap for that container; leaving it unset often allows swap equal to the memory limit; setting -1 allows unlimited swap up to what the host provides.
For plain docker compose (non‑Swarm), set service‑level attributes. The Compose Services reference explicitly supports cpus, mem_limit, memswap_limit and pids_limit on services [2].
services: api: image: ubuntu:22.04 command: ["sleep","infinity"] cpus: "1" # 50% of one CPU equivalent mem_limit: "256m" # hard RAM limit memswap_limit: "256m" # RAM+swap; equal to mem_limit disables swap pids_limit: 50 # max processes inside the container
A grumpy ItSec guy walks through the office when he overhears an exchange of words.
devops0: Two containers went rogue last night and starved the whole host. devops1: What are we supposed to do?
ItSec (walking by): Set limits. It's not rocket science. Docker exposes cgroup controls for CPU, memory, I/O and PIDs. Use them.
The point is: availability is part of security too. Linux control groups allow you to cap, isolate and observe resource usage, which is exactly how Docker enforces container limits for CPU, memory, block I/O and process counts [1]. Let's make it tangible with a small lab. We'll spin a container, install stress-ng, and watch limits in action.
# On the Docker host docker run -itd --name ubuntu-limits ubuntu:22.04 docker exec -it ubuntu-limits bash
# For my host nproc returns 4 stress-ng --cpu 4 --cpu-load 100 --timeout 30s
In another terminal, watch usage from the host.
docker stats
Now clamp CPU for the running container and see the throttle take effect.
docker update ubuntu-limits --cpus=1 docker stats
The --cpus flag is a wrapper over the Linux CFS period/quota; --cpus=1 caps the container at roughly one core worth of time on a multi‑core host.
Memory limits are similar. First tighten RAM and swap, then try to over‑allocate in the container.
# On the host docker update ubuntu-limits --memory=128m --memory-swap=256m docker stats
# Inside the container: stays under the cap stress-ng --vm 1 --vm-bytes 100M --timeout 30s --vm-keep
# Inside the container: tries to exceed; you may see reclaim/pressure instead of success stress-ng --vm 1 --vm-bytes 300M --timeout 30s --vm-keep
A few memory details matter. --memory is the hard ceiling; --memory-swap controls total RAM+swap available. Setting swap equal to memory disables swap for that container; leaving it unset often allows swap equal to the memory limit; setting -1 allows unlimited swap up to what the host provides.
For plain docker compose (non‑Swarm), set service‑level attributes. The Compose Services reference explicitly supports cpus, mem_limit, memswap_limit and pids_limit on services [2].
services: api: image: ubuntu:22.04 command: ["sleep","infinity"] cpus: "1" # 50% of one CPU equivalent mem_limit: "256m" # hard RAM limit memswap_limit: "256m" # RAM+swap; equal to mem_limit disables swap pids_limit: 50 # max processes inside the container
I cannot sing the praises of fetch loudly enough. As a #JavaScript#WebDev, having ready access to this native web API where you can pull down #HTML fragments or #JSON data with a line or two of code is simply brilliant.
But when shipping robust production code, how do you handle unpredictable network scenarios gracefully and provide a good user experience?
One solution: a tiny 2.3KB wrapper around “fetch” called “ffetch”. Here are some of its features:
I cannot sing the praises of fetch loudly enough. As a #JavaScript#WebDev, having ready access to this native web API where you can pull down #HTML fragments or #JSON data with a line or two of code is simply brilliant.
But when shipping robust production code, how do you handle unpredictable network scenarios gracefully and provide a good user experience?
One solution: a tiny 2.3KB wrapper around “fetch” called “ffetch”. Here are some of its features:
🎬 Skryptowanie nginx-a za pomocą js-a. Case study na rzecz wydajności i prywatności
@kuba z Fundacji @icd pokazuje, jak wykorzystać #JavaScript do skryptowania #NGINX oraz jak ta technika może poprawić wydajność i zwiększyć prywatność użytkowników.
🎬 Skryptowanie nginx-a za pomocą js-a. Case study na rzecz wydajności i prywatności
@kuba z Fundacji @icd pokazuje, jak wykorzystać #JavaScript do skryptowania #NGINX oraz jak ta technika może poprawić wydajność i zwiększyć prywatność użytkowników.
This is (will be) a Swiss-army knife type multi-tool for frequent little tasks I've been encountering and not found satisfactory equivalent other solutions for. So far, there're only two commands published, but a dozen or so more are to come (for which I still have more cleaning up to do, also in upstream projects):
- CSV-to-JSON parsing/conversion, with configurable filtering, renaming and column value coercions - De-dupe lines with support for regexp-based inclusions, exclusions and pattern-based uniqueness. Patterns can be read from files.
The readme contains installation instructions and documentation for all commands, their options and some example use cases. E.g. I regularly use the `dedupe-lines` command to cleanup my `.bash_history` file.
Using https://bun.sh, the tool can be compiled into a standalone executable.
All commands share common infrastructure of the main CLI tooling (based on https://thi.ng/args and many other https://thi.ng/umbrella packages). This reduces the code size of each command and makes it trivial to add additional commands (or share functionality, invoke some of those other commands for sub-tasks). There're also re-usable CLI arg specs to provide a uniform "API" for certain types of parameters.
Some of the still unreleased commands are for `ffmpeg` workflows/tasks, will update when ready...
Finally made that tool I've been planning for a while: A configurable batch deleter of #Mastodon#bookmarks, supporting a threshold date (i.e. only older bookmarks considered) and lists of accounts and hashtags to always keep.
After editing the script to fill in your own details and preferences at the top, you can run it via command line `node delete-bookmarks.js` or paste it in the browser console to execute.
The script outputs details of each bookmark being removed, supports retrying with exponential back-off (5x) and is configured to use quite generous pauses between requests to not trigger rate limiting.
The script also prints out `max_id` values, used for pagination purposes by the Mastodon API. Should you interrupt the script to make some changes and then re-run, you can also find the latest `max_id` and set `MAX_ID` to that value in the script to save time (bookmarks are processed in batches of 40)
(FWIW I've been ferociously bookmarking posts for almost 3 years (had ~13500) and my media storage became over 100GB. So it's urgent time for some serious pruning...)
🚨 Multiple CrowdStrike packages trojanized in an ongoing npm supply chain attack: This is the same campaign that hit Tinycolor yesterday with identical malware.
🚨 Multiple CrowdStrike packages trojanized in an ongoing npm supply chain attack: This is the same campaign that hit Tinycolor yesterday with identical malware.
🚨 Multiple CrowdStrike packages trojanized in an ongoing npm supply chain attack: This is the same campaign that hit Tinycolor yesterday with identical malware.
ALT text detailsCode snippet difference. An if statement checking the return value of the function item.visible is shown. Below, visibility checking if the function item.visible was truthy are shown
ALT text detailsScreenshot of a neovim session. The screen is zoomed very far out and split vertically into six sections. Each section shows around 150 lines of code from the file.
ALT text detailsScreenshot of a neovim session. The screen is zoomed very far out and split vertically into six sections. Each section shows around 150 lines of code from the file.
devops0: Our audit report says we must "enable Docker rootless mode". I have no clue what that even is... devops1: Sounds like some another security BS. What's "rootless" supposed to do?
ItSec: Relax. Rootless mode runs the Docker daemon and containers as a regular, unprivileged user [1]. It uses a user namespace, so both the daemon and your containers live in "user space", not as root. That shrinks the blast radius if the daemon or a app in container is compromised, because a breakout wouldn't hand out root on the host.
devops1: Fine. If it's "not hard" to implement, we can consider this.
ItSec: Deal.
Note: this mode does have some limitations. You can review them in docs [2].
First, let's check which user the Docker daemon is currently running as.
Then install the uid/gid mapping tools. On Ubuntu it's uidmap.
sudo apt update && sudo apt install -y uidmap
Docker provides a setup tool. If you installed official DEB/RPM packages, it's already in /usr/bin. Run it as your normal user.
dockerd-rootless-setuptool.sh install
If that command doesn't exist, install the extras package or use the official rootless script.
sudo apt-get install -y docker-ce-rootless-extras # or, without package manager access: curl -fsSL https://get.docker.com/rootless | sh
The tool creates a per-user systemd service, a "rootless" CLI context, and prints environment hints. You usually want your client to talk to the user-scoped socket permanently, so export DOCKER_HOST and persist it in your shell profile.
The primary NPM registry should be obsoleted entirely ASAP
JSR does not do anywhere near as much as it should, and it's probably too late to fix.
A proper successor must only support "standard" JS, though temporarily accepting "strippable types" is ok rn
All packages MUST be ESM (JSR ok here)
MUST include docstrings on all publicly-reachable interfaces.
MUST NOT include any type of dependency other than a named registry dependency with a semver version (no git deps etc)
MUST have a non-trivial README.
MUST be tied to a PUBLIC repo.
MUST NOT have install scripts (yeah sorry, the fight's over)
MUST clearly include a license, even if the license is "source available, not open source". This restriction MUST NOT limit to OSI's ridiculous list.
MUST have a name that is scoped to its publishing user/org (@foo/bar)All of the above constraints MUST be checked at publish time.
Furthermore, the registry MUST provide the following, based on this:
Full browsable (published) package sources, right on the site. With linkable paths. None of this absolute trash NPM decided to do.
Autogenerated API docs.
Lower-traffic packages that have not had a new version in 6 months should be completely delisted. They can be installed, with a warning printed.
Usernames/org names and package names must employ a suitably-aggressive levenshtein distance for potential conflicts. This should be aggressive.
Packages cannot be transferred between accounts, and it's against policy to allow others access to your personal account. Orgs can work around this.
Top 1000 packages (maybe more) have all new publishes put on hold for 7 days, and placed into a public review queue, overridden by [tbd?staff?]
Y'all aren't gonna like this but: package installation should be reasonably throttled. Both to keep costs down, and to encourage people to do something less lazy than "I'm just going to install all 2k dependencies on CI every time I push a docs change". It's wasteful and harmful for many reasons.
I think that's all I got off the top of my head for now.
There's honestly a lot of stuff that could be done on the client side to make life better, too, and y'all know I have a ton of thoughts on that, but I wanted to rant about registries for a bit, esp now that the NPM registry is crumbling.
Announcing Reciprocate, a Sweet Solution for Making Your HTML Web Components Reactive
Have you ever been chipping away on vanilla #WebComponents when you began to wonder “hey waitaminute…how do I make it so when I set this #JavaScript property, the equivalent #HTML attribute is updated? And if I set this attribute, the equivalent property is updated? Or when either is updated, my component will re-render?! Where are the APIs for this stuff??”
Announcing Reciprocate, a Sweet Solution for Making Your HTML Web Components Reactive
Have you ever been chipping away on vanilla #WebComponents when you began to wonder “hey waitaminute…how do I make it so when I set this #JavaScript property, the equivalent #HTML attribute is updated? And if I set this attribute, the equivalent property is updated? Or when either is updated, my component will re-render?! Where are the APIs for this stuff??”
Salut tout le monde, après cinq ans de salariat je me lance doucement en tant que #dev#freelance#javascript J'ai une première question existentielle : la création d'une micro-entreprise est censée être "simple", mais les explications sur les sites .gouv me semblent bien compliquées, et on trouve en parallèle pléthore de services payants pour déléguer la démarche. Quelqu'un a des conseils ou des retours d'expérience sur le sujet ?
We're excited to announce Optique 0.4.0, which brings significant improvements
to help text organization, enhanced documentation capabilities, and introduces
comprehensive Temporal API support.
Optique is a type-safe combinatorial CLI parser for TypeScript that makes
building command-line interfaces intuitive and maintainable. This release
focuses on making your CLI applications more user-friendly and maintainable.
Better help text organization
One of the most visible improvements in Optique 0.4.0 is the enhanced help text
organization. You can now label and group your options more effectively, making
complex CLIs much more approachable for users.
Labeled merge groups
The merge() combinator now accepts an optional label parameter, solving
a common pain point where developers had to choose between clean code structure
and organized help output:
// Before: unlabeled merged options appeared scatteredconst config = merge(connectionOptions, performanceOptions);// Now: group related options under a clear sectionconst config = merge( "Server Configuration", // New label parameter connectionOptions, performanceOptions);
This simple addition makes a huge difference in help text readability,
especially for CLIs with many options spread across multiple reusable modules.
The resulting help output clearly organizes options under
the Server Configuration section:
Demo app showcasing labeled merge groupsUsage: demo-merge.ts --host STRING --port INTEGER --timeout INTEGER --retries INTEGERServer Configuration: --host STRING Server hostname or IP address --port INTEGER Port number for the connection --timeout INTEGER Connection timeout in seconds --retries INTEGER Number of retry attempts
The new group() combinator
For cases where merge() doesn't apply, the new group()
combinator lets you wrap any parser with a documentation label:
// Group mutually exclusive options under a clear sectionconst outputFormat = group( "Output Format", or( map(flag("--json"), () => "json"), map(flag("--yaml"), () => "yaml"), map(flag("--xml"), () => "xml"), ));
This is particularly useful for organizing mutually exclusive flags, multiple
inputs, or any parser that doesn't natively support labeling. The resulting
help text becomes much more scannable and user-friendly.
Here's how the grouped output format options appear in the help text:
Demo app showcasing group combinatorUsage: demo-group.ts --json demo-group.ts --yaml demo-group.ts --xmlOutput Format: --json Output in JSON format --yaml Output in YAML format --xml Output in XML format
Rich documentation support
Optique 0.4.0 introduces comprehensive documentation fields that can be added
directly through the run() function, eliminating the need to modify parser
definitions for documentation purposes.
Brief descriptions, detailed explanations, and footers
Both @optique/core/facade and @optique/run now support brief,
description, and footer options through the run() function:
import { run } from "@optique/run";import { message } from "@optique/core/message";const result = run(parser, { brief: message`A powerful data processing tool`, description: message`This tool provides comprehensive data processing capabilities with support for multiple formats and transformations. It can handle JSON, YAML, and CSV files with automatic format detection.`, footer: message`Examples: myapp process data.json --format yaml myapp validate config.toml --strictFor more information, visit https://example.com/docs`, help: "option"});
These documentation fields appear in both help output and error messages
(when configured), providing consistent context throughout your CLI's user
experience.
The complete help output demonstrates the rich documentation features with brief
description, detailed explanation, option descriptions, default values,
and footer information:
A powerful data processing toolUsage: demo-rich-docs.ts [--port INTEGER] [--format STRING] --verbose STRINGThis tool provides comprehensive data processing capabilities with support formultiple formats and transformations. It can handle JSON, YAML, and CSV fileswith automatic format detection. --port INTEGER Server port number [3000] --format STRING Output format [json] --verbose STRING Verbosity levelExamples: myapp process data.json --format yaml myapp validate config.toml --strictFor more information, visit https://example.com/docs
These documentation fields appear in both help output and error messages
(when configured), providing consistent context throughout your CLI's user
experience.
Display default values
A frequently requested feature is now available: showing default values
directly in help text. Enable this with the new showDefault option when
using withDefault():
Default values are automatically dimmed when colors are enabled, making them
visually distinct while remaining readable.
The help output shows default values clearly marked next to each option:
Usage: demo-defaults.ts [--port INTEGER] [--format STRING] --port INTEGER Server port number [3000] --format STRING Output format [json]
Temporal API support
Optique 0.4.0 introduces a new package, @optique/temporal, providing
comprehensive support for the modern Temporal API. This brings type-safe
parsing for dates, times, durations, and time zones:
import { instant, duration, zonedDateTime } from "@optique/temporal";import { option } from "@optique/core/parser";const parser = object({ // Parse ISO 8601 timestamps timestamp: option("--at", instant()), // Parse durations like "PT30M" or "P1DT2H" timeout: option("--timeout", duration()), // Parse zoned datetime with timezone info meeting: option("--meeting", zonedDateTime()),});
The temporal parsers return native Temporal objects with full functionality:
The merge() combinator now supports up to 10 parsers (previously 5), and
the tuple() parser has improved type inference using TypeScript's const
type parameter. These enhancements enable more complex CLI structures while
maintaining perfect type safety.
Breaking changes
While we've maintained backward compatibility for most APIs, there are a few
changes to be aware of:
The Parser.getDocFragments() method now uses DocState<TState> instead
of direct state values (only affects custom parser implementations)
The merge() combinator now enforces stricter type
constraints at compile time, rejecting non-object-producing parsers
Learn more
For a complete list of changes, bug fixes, and improvements, see the
full changelog.
We hope these improvements make building CLI applications with Optique even
more enjoyable. As always, we welcome your feedback and contributions on
GitHub.
We're excited to announce Optique 0.4.0, which brings significant improvements
to help text organization, enhanced documentation capabilities, and introduces
comprehensive Temporal API support.
Optique is a type-safe combinatorial CLI parser for TypeScript that makes
building command-line interfaces intuitive and maintainable. This release
focuses on making your CLI applications more user-friendly and maintainable.
Better help text organization
One of the most visible improvements in Optique 0.4.0 is the enhanced help text
organization. You can now label and group your options more effectively, making
complex CLIs much more approachable for users.
Labeled merge groups
The merge() combinator now accepts an optional label parameter, solving
a common pain point where developers had to choose between clean code structure
and organized help output:
// Before: unlabeled merged options appeared scatteredconst config = merge(connectionOptions, performanceOptions);// Now: group related options under a clear sectionconst config = merge( "Server Configuration", // New label parameter connectionOptions, performanceOptions);
This simple addition makes a huge difference in help text readability,
especially for CLIs with many options spread across multiple reusable modules.
The resulting help output clearly organizes options under
the Server Configuration section:
Demo app showcasing labeled merge groupsUsage: demo-merge.ts --host STRING --port INTEGER --timeout INTEGER --retries INTEGERServer Configuration: --host STRING Server hostname or IP address --port INTEGER Port number for the connection --timeout INTEGER Connection timeout in seconds --retries INTEGER Number of retry attempts
The new group() combinator
For cases where merge() doesn't apply, the new group()
combinator lets you wrap any parser with a documentation label:
// Group mutually exclusive options under a clear sectionconst outputFormat = group( "Output Format", or( map(flag("--json"), () => "json"), map(flag("--yaml"), () => "yaml"), map(flag("--xml"), () => "xml"), ));
This is particularly useful for organizing mutually exclusive flags, multiple
inputs, or any parser that doesn't natively support labeling. The resulting
help text becomes much more scannable and user-friendly.
Here's how the grouped output format options appear in the help text:
Demo app showcasing group combinatorUsage: demo-group.ts --json demo-group.ts --yaml demo-group.ts --xmlOutput Format: --json Output in JSON format --yaml Output in YAML format --xml Output in XML format
Rich documentation support
Optique 0.4.0 introduces comprehensive documentation fields that can be added
directly through the run() function, eliminating the need to modify parser
definitions for documentation purposes.
Brief descriptions, detailed explanations, and footers
Both @optique/core/facade and @optique/run now support brief,
description, and footer options through the run() function:
import { run } from "@optique/run";import { message } from "@optique/core/message";const result = run(parser, { brief: message`A powerful data processing tool`, description: message`This tool provides comprehensive data processing capabilities with support for multiple formats and transformations. It can handle JSON, YAML, and CSV files with automatic format detection.`, footer: message`Examples: myapp process data.json --format yaml myapp validate config.toml --strictFor more information, visit https://example.com/docs`, help: "option"});
These documentation fields appear in both help output and error messages
(when configured), providing consistent context throughout your CLI's user
experience.
The complete help output demonstrates the rich documentation features with brief
description, detailed explanation, option descriptions, default values,
and footer information:
A powerful data processing toolUsage: demo-rich-docs.ts [--port INTEGER] [--format STRING] --verbose STRINGThis tool provides comprehensive data processing capabilities with support formultiple formats and transformations. It can handle JSON, YAML, and CSV fileswith automatic format detection. --port INTEGER Server port number [3000] --format STRING Output format [json] --verbose STRING Verbosity levelExamples: myapp process data.json --format yaml myapp validate config.toml --strictFor more information, visit https://example.com/docs
These documentation fields appear in both help output and error messages
(when configured), providing consistent context throughout your CLI's user
experience.
Display default values
A frequently requested feature is now available: showing default values
directly in help text. Enable this with the new showDefault option when
using withDefault():
Default values are automatically dimmed when colors are enabled, making them
visually distinct while remaining readable.
The help output shows default values clearly marked next to each option:
Usage: demo-defaults.ts [--port INTEGER] [--format STRING] --port INTEGER Server port number [3000] --format STRING Output format [json]
Temporal API support
Optique 0.4.0 introduces a new package, @optique/temporal, providing
comprehensive support for the modern Temporal API. This brings type-safe
parsing for dates, times, durations, and time zones:
import { instant, duration, zonedDateTime } from "@optique/temporal";import { option } from "@optique/core/parser";const parser = object({ // Parse ISO 8601 timestamps timestamp: option("--at", instant()), // Parse durations like "PT30M" or "P1DT2H" timeout: option("--timeout", duration()), // Parse zoned datetime with timezone info meeting: option("--meeting", zonedDateTime()),});
The temporal parsers return native Temporal objects with full functionality:
The merge() combinator now supports up to 10 parsers (previously 5), and
the tuple() parser has improved type inference using TypeScript's const
type parameter. These enhancements enable more complex CLI structures while
maintaining perfect type safety.
Breaking changes
While we've maintained backward compatibility for most APIs, there are a few
changes to be aware of:
The Parser.getDocFragments() method now uses DocState<TState> instead
of direct state values (only affects custom parser implementations)
The merge() combinator now enforces stricter type
constraints at compile time, rejecting non-object-producing parsers
Learn more
For a complete list of changes, bug fixes, and improvements, see the
full changelog.
We hope these improvements make building CLI applications with Optique even
more enjoyable. As always, we welcome your feedback and contributions on
GitHub.
We're excited to announce Optique 0.4.0, which brings significant improvements
to help text organization, enhanced documentation capabilities, and introduces
comprehensive Temporal API support.
Optique is a type-safe combinatorial CLI parser for TypeScript that makes
building command-line interfaces intuitive and maintainable. This release
focuses on making your CLI applications more user-friendly and maintainable.
Better help text organization
One of the most visible improvements in Optique 0.4.0 is the enhanced help text
organization. You can now label and group your options more effectively, making
complex CLIs much more approachable for users.
Labeled merge groups
The merge() combinator now accepts an optional label parameter, solving
a common pain point where developers had to choose between clean code structure
and organized help output:
// Before: unlabeled merged options appeared scatteredconst config = merge(connectionOptions, performanceOptions);// Now: group related options under a clear sectionconst config = merge( "Server Configuration", // New label parameter connectionOptions, performanceOptions);
This simple addition makes a huge difference in help text readability,
especially for CLIs with many options spread across multiple reusable modules.
The resulting help output clearly organizes options under
the Server Configuration section:
Demo app showcasing labeled merge groupsUsage: demo-merge.ts --host STRING --port INTEGER --timeout INTEGER --retries INTEGERServer Configuration: --host STRING Server hostname or IP address --port INTEGER Port number for the connection --timeout INTEGER Connection timeout in seconds --retries INTEGER Number of retry attempts
The new group() combinator
For cases where merge() doesn't apply, the new group()
combinator lets you wrap any parser with a documentation label:
// Group mutually exclusive options under a clear sectionconst outputFormat = group( "Output Format", or( map(flag("--json"), () => "json"), map(flag("--yaml"), () => "yaml"), map(flag("--xml"), () => "xml"), ));
This is particularly useful for organizing mutually exclusive flags, multiple
inputs, or any parser that doesn't natively support labeling. The resulting
help text becomes much more scannable and user-friendly.
Here's how the grouped output format options appear in the help text:
Demo app showcasing group combinatorUsage: demo-group.ts --json demo-group.ts --yaml demo-group.ts --xmlOutput Format: --json Output in JSON format --yaml Output in YAML format --xml Output in XML format
Rich documentation support
Optique 0.4.0 introduces comprehensive documentation fields that can be added
directly through the run() function, eliminating the need to modify parser
definitions for documentation purposes.
Brief descriptions, detailed explanations, and footers
Both @optique/core/facade and @optique/run now support brief,
description, and footer options through the run() function:
import { run } from "@optique/run";import { message } from "@optique/core/message";const result = run(parser, { brief: message`A powerful data processing tool`, description: message`This tool provides comprehensive data processing capabilities with support for multiple formats and transformations. It can handle JSON, YAML, and CSV files with automatic format detection.`, footer: message`Examples: myapp process data.json --format yaml myapp validate config.toml --strictFor more information, visit https://example.com/docs`, help: "option"});
These documentation fields appear in both help output and error messages
(when configured), providing consistent context throughout your CLI's user
experience.
The complete help output demonstrates the rich documentation features with brief
description, detailed explanation, option descriptions, default values,
and footer information:
A powerful data processing toolUsage: demo-rich-docs.ts [--port INTEGER] [--format STRING] --verbose STRINGThis tool provides comprehensive data processing capabilities with support formultiple formats and transformations. It can handle JSON, YAML, and CSV fileswith automatic format detection. --port INTEGER Server port number [3000] --format STRING Output format [json] --verbose STRING Verbosity levelExamples: myapp process data.json --format yaml myapp validate config.toml --strictFor more information, visit https://example.com/docs
These documentation fields appear in both help output and error messages
(when configured), providing consistent context throughout your CLI's user
experience.
Display default values
A frequently requested feature is now available: showing default values
directly in help text. Enable this with the new showDefault option when
using withDefault():
Default values are automatically dimmed when colors are enabled, making them
visually distinct while remaining readable.
The help output shows default values clearly marked next to each option:
Usage: demo-defaults.ts [--port INTEGER] [--format STRING] --port INTEGER Server port number [3000] --format STRING Output format [json]
Temporal API support
Optique 0.4.0 introduces a new package, @optique/temporal, providing
comprehensive support for the modern Temporal API. This brings type-safe
parsing for dates, times, durations, and time zones:
import { instant, duration, zonedDateTime } from "@optique/temporal";import { option } from "@optique/core/parser";const parser = object({ // Parse ISO 8601 timestamps timestamp: option("--at", instant()), // Parse durations like "PT30M" or "P1DT2H" timeout: option("--timeout", duration()), // Parse zoned datetime with timezone info meeting: option("--meeting", zonedDateTime()),});
The temporal parsers return native Temporal objects with full functionality:
The merge() combinator now supports up to 10 parsers (previously 5), and
the tuple() parser has improved type inference using TypeScript's const
type parameter. These enhancements enable more complex CLI structures while
maintaining perfect type safety.
Breaking changes
While we've maintained backward compatibility for most APIs, there are a few
changes to be aware of:
The Parser.getDocFragments() method now uses DocState<TState> instead
of direct state values (only affects custom parser implementations)
The merge() combinator now enforces stricter type
constraints at compile time, rejecting non-object-producing parsers
Learn more
For a complete list of changes, bug fixes, and improvements, see the
full changelog.
We hope these improvements make building CLI applications with Optique even
more enjoyable. As always, we welcome your feedback and contributions on
GitHub.
In a shocking development, new additions to the #ECMAScript standard WILL UNLEASH THE HERETOFORE UNAVAILABLE POWER OF ADDITION _IN JAVASCRIPT_ upon the world!
ALT text detailslet numbers1 = [Number.MAX_VALUE, 1, -Number.MAX_VALUE];
numbers1.reduce1((a, b) => a + b);
Math.sumPrecise(numbers1);
let numbers2 = [0.1, 0.2, 0.3];
numbers2.reduce((a, b) => a + b);
Math.sumPrecise(numbers2);
/* ECMAScript Stage 4 proposal, works in Firefox today! */
Yesterday I released new versions of https://thi.ng/wasm-api (and its add-on packages), a modular and extensible bridge API & toolchain for hybrid JS/TS/Zig/WebAssembly apps, now updated to be compatible with the latest Zig version 0.15.1...
The update addresses some of Zig's breaking syntax & build system changes only, nothing on the JS/TS side has changed. As a result https://thi.ng/wasm-api-dom has a slightly revised internal structure (also a breaking change, but nothing major & unavoidable). All bundled Zig examples[1] in the repo have been updated too, take a look for reference (if needed).
Specifically, the removal of `usingnamespace` has had a major impact on the existing handling of generated types in these wasm-api support packages (or your own) and now forces an additional level of hierarchy in terms of namespacing. This is because `usingnamespace` enabled a form of namespace merging, which allowed the generated WASM⭤TS interop types (written to their own sourcefile) to be merged/hoisted into the main library module.
For example, previously after importing `const dom = @import("wasm-api-dom");` we could refer to a type via `dom.WindowInfo`. Now with namespace merging removed, we have to use `dom.types.WindowInfo`. As I said, it's not a major departure, but a breaking change nonetheless[2]...
The `build.zig` file bundled with https://thi.ng/wasm-api is now also only compatible with Zig 0.15.1 (for now). Build files for older Zig versions are still included too (in the same directory)[3].
Lastly, once more for the record: The wasm-api bridge itself is NOT tied to Zig (or a particular version), however it's the main use case/language for my own WebAssembly use cases...
[2] The existing design of these modules helped to keep these breaking changes to a minimum in userland code and these updates are all following the same uniform pattern (i.e. exposing interop types via `modulename.types.TypeName`...)
ALT text detailsBlack background promotional banner. Large white bold text at the top reads: “LABOR DAY SALE 35% OFF SITEWIDE.” Below, smaller yellow text reads: “USE CODE LABORDAY35.” Further down in white text: “ends 9/1/2025 23:59 PDT.” In the bottom left corner, there is the classic No Starch Press coffee robot.
i realise everyone has probably forgotten me and with think, who is this spammer, but after 9 months without fediverse, I figured that i better login to explain myself.
Basically near the start of the year two things happened at the same time to make it impossible to access fedi. Anyway Im enabling #javascript in a browser now to tell you this but i NEVER enable javascript in this browser normally and will probably disable it again, hopefully not for 9 months but this #distrohop is a BIG one, more like a distro-leap! @nimda it would really help if the #BloatFE interface was available over #i2p. @silverpil is there anyway to force a non-js experience, using a specific uri combo? FYI ive been recommending #mitra more in the meatspace lately, so heads up you may be getting more traffic??? or not.... lol
@gabriel i LOVED ur interview on #corbettReport, it is disconcerting to see his non-acknowledgment of your interest in #fediverse. He has known about fedi for a long time and probably should have known better than to pump S.S. (i mean sCRubstack), anyway sorry to hear u were set upon by S.S. drones. I've been meaning to inform u that your libresolutionsnetork.i2p site is broken, it redirects to gabe.i2p, so i may be missing out on insights. i was enjoying your updates on ur health drive but havnt been able to keep upto date lately.
The recent #openSource orgs sign onto the #unitedNations pact is super creepy. The last clause, ie. to do the bidding of the United Nations makes me a bit squeemish, just because we all saw covid, right? Even the other clauses about "diversity and inclusion" a nasty, and seem to require developers identify themselves, meaning no more anonymous contributions? i expect better from the #libreoffice folks that to sign onto something like this (i already knew #gnome were heading down a nasty path by their locked-down communication channels). My feeling is this is a result of the engineered #inflation ( #covid / #nft / #moneylaundering) crises means people are grasping at straws to maintain their income and status, forcing developers to accept ridiculous contracts. i dont know. Maybe im talking out a nether orifice. If i hear that everyone is plotting forks of LibreOffice and GNOME, it wouldnt surprise me.
I'm also interested in what appears to be the lawfare-based extortion of archive.org, not able to research it lately. I bet a billion bitcoins (that will never exist, because bitcoin is capped at 21 million) that #archiveDotOrg no longer accept #bitcoin donations. AMIRIGHT? (i dunno again I might be wrong, i literally have not checked, lol but seriously they are partnering with the US government to be a repo of govt documents??? now???)
The word of the day is '#SUSPECT'
... and remember everyone, #iran is to blame for ALL OF IT. including of cause the genocide that almost everyone on fedi knew was a #genocide almost 2 years ago. Why would it take 2 years for people on corporate media pratforms to work this out.... INSERT THINKING EMOJI
anyway there is so much to talk about and i will not be able to do it now. and will not be checking messages, because my connection is REALLY, REALLY, REALLY bad now. and i'll be here forever and die. so this is just a i'm still alive, just working thru technical coincidental problems.
love you all, and hopefully i can be online proper, in the near future.
We're excited to announce the release of BotKit 0.3.0! This release marks a significant milestone as #BotKit now supports #Node.js alongside #Deno, making it accessible to a wider audience. The minimum required Node.js version is 22.0.0. This dual-runtime support means you can now choose your preferred #JavaScript runtime while building #ActivityPub#bots with the same powerful BotKit APIs.
One of the most requested features has landed: poll support! You can now create interactive polls in your #bot messages, allowing followers to vote on questions with single or multiple-choice options. Polls are represented as ActivityPub Question objects with proper expiration times, and your bot can react to votes through the new onVote event handler. This feature enhances engagement possibilities and brings BotKit to feature parity with major #fediverse platforms like Mastodon and Misskey.
The web frontend has been enhanced with a new followers page, thanks to the contribution from Hyeonseo Kim (@gaebalgom)! The /followers route now displays a paginated list of your bot's followers, and the follower count on the main profile page is now clickable, providing better visibility into your bot's audience. This improvement makes the web interface more complete and user-friendly.
For developers looking for alternative storage backends, we've introduced the SqliteRepository through the new @fedify/botkit-sqlite package. This provides a production-ready SQLite-based storage solution with ACID compliance, write-ahead logging (WAL) for optimal performance, and proper indexing. Additionally, the new @fedify/botkit/repository module offers MemoryCachedRepository for adding an in-memory cache layer on top of any repository implementation, improving read performance for frequently accessed data.
This release also includes an important security update: we've upgraded to #Fedify 1.8.8, ensuring your bots stay secure and compatible with the latest ActivityPub standards. The repository pattern has been expanded with new interfaces and types like RepositoryGetMessagesOptions, RepositoryGetFollowersOptions, and proper support for polls storage through the KvStoreRepositoryPrefixes.polls option, providing more flexibility for custom implementations.
We're excited to announce the release of BotKit 0.3.0! This release marks a significant milestone as #BotKit now supports #Node.js alongside #Deno, making it accessible to a wider audience. The minimum required Node.js version is 22.0.0. This dual-runtime support means you can now choose your preferred #JavaScript runtime while building #ActivityPub#bots with the same powerful BotKit APIs.
One of the most requested features has landed: poll support! You can now create interactive polls in your #bot messages, allowing followers to vote on questions with single or multiple-choice options. Polls are represented as ActivityPub Question objects with proper expiration times, and your bot can react to votes through the new onVote event handler. This feature enhances engagement possibilities and brings BotKit to feature parity with major #fediverse platforms like Mastodon and Misskey.
The web frontend has been enhanced with a new followers page, thanks to the contribution from Hyeonseo Kim (@gaebalgom)! The /followers route now displays a paginated list of your bot's followers, and the follower count on the main profile page is now clickable, providing better visibility into your bot's audience. This improvement makes the web interface more complete and user-friendly.
For developers looking for alternative storage backends, we've introduced the SqliteRepository through the new @fedify/botkit-sqlite package. This provides a production-ready SQLite-based storage solution with ACID compliance, write-ahead logging (WAL) for optimal performance, and proper indexing. Additionally, the new @fedify/botkit/repository module offers MemoryCachedRepository for adding an in-memory cache layer on top of any repository implementation, improving read performance for frequently accessed data.
This release also includes an important security update: we've upgraded to #Fedify 1.8.8, ensuring your bots stay secure and compatible with the latest ActivityPub standards. The repository pattern has been expanded with new interfaces and types like RepositoryGetMessagesOptions, RepositoryGetFollowersOptions, and proper support for polls storage through the KvStoreRepositoryPrefixes.polls option, providing more flexibility for custom implementations.
We're excited to announce the release of BotKit 0.3.0! This release marks a significant milestone as #BotKit now supports #Node.js alongside #Deno, making it accessible to a wider audience. The minimum required Node.js version is 22.0.0. This dual-runtime support means you can now choose your preferred #JavaScript runtime while building #ActivityPub#bots with the same powerful BotKit APIs.
One of the most requested features has landed: poll support! You can now create interactive polls in your #bot messages, allowing followers to vote on questions with single or multiple-choice options. Polls are represented as ActivityPub Question objects with proper expiration times, and your bot can react to votes through the new onVote event handler. This feature enhances engagement possibilities and brings BotKit to feature parity with major #fediverse platforms like Mastodon and Misskey.
The web frontend has been enhanced with a new followers page, thanks to the contribution from Hyeonseo Kim (@gaebalgom)! The /followers route now displays a paginated list of your bot's followers, and the follower count on the main profile page is now clickable, providing better visibility into your bot's audience. This improvement makes the web interface more complete and user-friendly.
For developers looking for alternative storage backends, we've introduced the SqliteRepository through the new @fedify/botkit-sqlite package. This provides a production-ready SQLite-based storage solution with ACID compliance, write-ahead logging (WAL) for optimal performance, and proper indexing. Additionally, the new @fedify/botkit/repository module offers MemoryCachedRepository for adding an in-memory cache layer on top of any repository implementation, improving read performance for frequently accessed data.
This release also includes an important security update: we've upgraded to #Fedify 1.8.8, ensuring your bots stay secure and compatible with the latest ActivityPub standards. The repository pattern has been expanded with new interfaces and types like RepositoryGetMessagesOptions, RepositoryGetFollowersOptions, and proper support for polls storage through the KvStoreRepositoryPrefixes.polls option, providing more flexibility for custom implementations.
We're excited to announce the release of BotKit 0.3.0! This release marks a significant milestone as #BotKit now supports #Node.js alongside #Deno, making it accessible to a wider audience. The minimum required Node.js version is 22.0.0. This dual-runtime support means you can now choose your preferred #JavaScript runtime while building #ActivityPub#bots with the same powerful BotKit APIs.
One of the most requested features has landed: poll support! You can now create interactive polls in your #bot messages, allowing followers to vote on questions with single or multiple-choice options. Polls are represented as ActivityPub Question objects with proper expiration times, and your bot can react to votes through the new onVote event handler. This feature enhances engagement possibilities and brings BotKit to feature parity with major #fediverse platforms like Mastodon and Misskey.
The web frontend has been enhanced with a new followers page, thanks to the contribution from Hyeonseo Kim (@gaebalgom)! The /followers route now displays a paginated list of your bot's followers, and the follower count on the main profile page is now clickable, providing better visibility into your bot's audience. This improvement makes the web interface more complete and user-friendly.
For developers looking for alternative storage backends, we've introduced the SqliteRepository through the new @fedify/botkit-sqlite package. This provides a production-ready SQLite-based storage solution with ACID compliance, write-ahead logging (WAL) for optimal performance, and proper indexing. Additionally, the new @fedify/botkit/repository module offers MemoryCachedRepository for adding an in-memory cache layer on top of any repository implementation, improving read performance for frequently accessed data.
This release also includes an important security update: we've upgraded to #Fedify 1.8.8, ensuring your bots stay secure and compatible with the latest ActivityPub standards. The repository pattern has been expanded with new interfaces and types like RepositoryGetMessagesOptions, RepositoryGetFollowersOptions, and proper support for polls storage through the KvStoreRepositoryPrefixes.polls option, providing more flexibility for custom implementations.
We're excited to announce the release of BotKit 0.3.0! This release marks a significant milestone as #BotKit now supports #Node.js alongside #Deno, making it accessible to a wider audience. The minimum required Node.js version is 22.0.0. This dual-runtime support means you can now choose your preferred #JavaScript runtime while building #ActivityPub#bots with the same powerful BotKit APIs.
One of the most requested features has landed: poll support! You can now create interactive polls in your #bot messages, allowing followers to vote on questions with single or multiple-choice options. Polls are represented as ActivityPub Question objects with proper expiration times, and your bot can react to votes through the new onVote event handler. This feature enhances engagement possibilities and brings BotKit to feature parity with major #fediverse platforms like Mastodon and Misskey.
The web frontend has been enhanced with a new followers page, thanks to the contribution from Hyeonseo Kim (@gaebalgom)! The /followers route now displays a paginated list of your bot's followers, and the follower count on the main profile page is now clickable, providing better visibility into your bot's audience. This improvement makes the web interface more complete and user-friendly.
For developers looking for alternative storage backends, we've introduced the SqliteRepository through the new @fedify/botkit-sqlite package. This provides a production-ready SQLite-based storage solution with ACID compliance, write-ahead logging (WAL) for optimal performance, and proper indexing. Additionally, the new @fedify/botkit/repository module offers MemoryCachedRepository for adding an in-memory cache layer on top of any repository implementation, improving read performance for frequently accessed data.
This release also includes an important security update: we've upgraded to #Fedify 1.8.8, ensuring your bots stay secure and compatible with the latest ActivityPub standards. The repository pattern has been expanded with new interfaces and types like RepositoryGetMessagesOptions, RepositoryGetFollowersOptions, and proper support for polls storage through the KvStoreRepositoryPrefixes.polls option, providing more flexibility for custom implementations.
We're excited to announce the release of BotKit 0.3.0! This release marks a significant milestone as #BotKit now supports #Node.js alongside #Deno, making it accessible to a wider audience. The minimum required Node.js version is 22.0.0. This dual-runtime support means you can now choose your preferred #JavaScript runtime while building #ActivityPub#bots with the same powerful BotKit APIs.
One of the most requested features has landed: poll support! You can now create interactive polls in your #bot messages, allowing followers to vote on questions with single or multiple-choice options. Polls are represented as ActivityPub Question objects with proper expiration times, and your bot can react to votes through the new onVote event handler. This feature enhances engagement possibilities and brings BotKit to feature parity with major #fediverse platforms like Mastodon and Misskey.
The web frontend has been enhanced with a new followers page, thanks to the contribution from Hyeonseo Kim (@gaebalgom)! The /followers route now displays a paginated list of your bot's followers, and the follower count on the main profile page is now clickable, providing better visibility into your bot's audience. This improvement makes the web interface more complete and user-friendly.
For developers looking for alternative storage backends, we've introduced the SqliteRepository through the new @fedify/botkit-sqlite package. This provides a production-ready SQLite-based storage solution with ACID compliance, write-ahead logging (WAL) for optimal performance, and proper indexing. Additionally, the new @fedify/botkit/repository module offers MemoryCachedRepository for adding an in-memory cache layer on top of any repository implementation, improving read performance for frequently accessed data.
This release also includes an important security update: we've upgraded to #Fedify 1.8.8, ensuring your bots stay secure and compatible with the latest ActivityPub standards. The repository pattern has been expanded with new interfaces and types like RepositoryGetMessagesOptions, RepositoryGetFollowersOptions, and proper support for polls storage through the KvStoreRepositoryPrefixes.polls option, providing more flexibility for custom implementations.
We're excited to announce the release of BotKit 0.3.0! This release marks a significant milestone as #BotKit now supports #Node.js alongside #Deno, making it accessible to a wider audience. The minimum required Node.js version is 22.0.0. This dual-runtime support means you can now choose your preferred #JavaScript runtime while building #ActivityPub#bots with the same powerful BotKit APIs.
One of the most requested features has landed: poll support! You can now create interactive polls in your #bot messages, allowing followers to vote on questions with single or multiple-choice options. Polls are represented as ActivityPub Question objects with proper expiration times, and your bot can react to votes through the new onVote event handler. This feature enhances engagement possibilities and brings BotKit to feature parity with major #fediverse platforms like Mastodon and Misskey.
The web frontend has been enhanced with a new followers page, thanks to the contribution from Hyeonseo Kim (@gaebalgom)! The /followers route now displays a paginated list of your bot's followers, and the follower count on the main profile page is now clickable, providing better visibility into your bot's audience. This improvement makes the web interface more complete and user-friendly.
For developers looking for alternative storage backends, we've introduced the SqliteRepository through the new @fedify/botkit-sqlite package. This provides a production-ready SQLite-based storage solution with ACID compliance, write-ahead logging (WAL) for optimal performance, and proper indexing. Additionally, the new @fedify/botkit/repository module offers MemoryCachedRepository for adding an in-memory cache layer on top of any repository implementation, improving read performance for frequently accessed data.
This release also includes an important security update: we've upgraded to #Fedify 1.8.8, ensuring your bots stay secure and compatible with the latest ActivityPub standards. The repository pattern has been expanded with new interfaces and types like RepositoryGetMessagesOptions, RepositoryGetFollowersOptions, and proper support for polls storage through the KvStoreRepositoryPrefixes.polls option, providing more flexibility for custom implementations.
We're excited to announce the release of BotKit 0.3.0! This release marks a significant milestone as #BotKit now supports #Node.js alongside #Deno, making it accessible to a wider audience. The minimum required Node.js version is 22.0.0. This dual-runtime support means you can now choose your preferred #JavaScript runtime while building #ActivityPub#bots with the same powerful BotKit APIs.
One of the most requested features has landed: poll support! You can now create interactive polls in your #bot messages, allowing followers to vote on questions with single or multiple-choice options. Polls are represented as ActivityPub Question objects with proper expiration times, and your bot can react to votes through the new onVote event handler. This feature enhances engagement possibilities and brings BotKit to feature parity with major #fediverse platforms like Mastodon and Misskey.
The web frontend has been enhanced with a new followers page, thanks to the contribution from Hyeonseo Kim (@gaebalgom)! The /followers route now displays a paginated list of your bot's followers, and the follower count on the main profile page is now clickable, providing better visibility into your bot's audience. This improvement makes the web interface more complete and user-friendly.
For developers looking for alternative storage backends, we've introduced the SqliteRepository through the new @fedify/botkit-sqlite package. This provides a production-ready SQLite-based storage solution with ACID compliance, write-ahead logging (WAL) for optimal performance, and proper indexing. Additionally, the new @fedify/botkit/repository module offers MemoryCachedRepository for adding an in-memory cache layer on top of any repository implementation, improving read performance for frequently accessed data.
This release also includes an important security update: we've upgraded to #Fedify 1.8.8, ensuring your bots stay secure and compatible with the latest ActivityPub standards. The repository pattern has been expanded with new interfaces and types like RepositoryGetMessagesOptions, RepositoryGetFollowersOptions, and proper support for polls storage through the KvStoreRepositoryPrefixes.polls option, providing more flexibility for custom implementations.
If you get JSON back, then you've handed that container admin-level control of the Docker daemon - so please don't...
devops0: So what? What does it mean?
Let's learn by example. The Docker CLI talks to the Docker daemon over a UNIX socket at (by default) /var/run/docker.sock [1]. That socket exposes the Docker Engine's REST API. With it, you can list, start, stop, create, or reconfigure containers - effectively controlling the host via the daemon. Now, the oops pattern we seeing:
# Dangerous: gives the container full control of the Docker daemon docker run -it -v /var/run/docker.sock:/var/run/docker.sock ubuntu:24.04
If an attacker gets any code execution in that container (RCE, webshell, deserialization bug, etc), they can pivot to the Docker host. Here's how in practice:
# 1) From the compromised container that "sees" docker.sock: create a "helper" container that bind-mounts the host root
# Step 2, read output of previous command (replace exec ID with yours): curl --unix-socket /var/run/docker.sock -s --no-buffer \ -H 'Content-Type: application/json' \ -X POST http://localhost/exec/1ec29063e5c13ac73b907f57470552dd39519bad293bf6677bedadaad9fcde89/start \ -d '{"Detach": false, "Tty": true}'
Keep in mind this isn't only an RCE issue: SSRF-style bugs can coerce internal services into calling local admin endpoints (including docker.sock or a TCP-exposed daemon).
And one more important point: we understand you may not like when texts like this include conditionals: if a container is compromised, if SSRF exists, then the socket becomes a bridge to owning the host. It's understandable. Our job, however, is to assume those "ifs" eventually happen and remove the easy paths for bad actors.
Wow! You know that #Web#Tech is getting really good when you are able to replace significant amounts of #JavaScript with a few lines of #HTML and #CSS. Best part is the fact that you get #a11y out of the box with native widgets 🙌
A few examples: `<dialog closedby="any">`, stylable `<select>` and even HTML autocomplete/typeahead using the `<datalist>`.
Wow! You know that #Web#Tech is getting really good when you are able to replace significant amounts of #JavaScript with a few lines of #HTML and #CSS. Best part is the fact that you get #a11y out of the box with native widgets 🙌
A few examples: `<dialog closedby="any">`, stylable `<select>` and even HTML autocomplete/typeahead using the `<datalist>`.
Hello Fediverse! I wanted to update my intro since things in my life are always updating and changing. I'm on a journey from "tech guru" to full-stack dev. I'm building my skills one line of code at a time. I'm also a huge fan of Star Wars, Marvel, and B-rated movies that are so bad it's good. Always down to talk tech. Let's connect!💬
Hey y'all, a new #fediverse social web forum is in da house!! 🎉
Talk learning #WebDev from base principles and help fellow newbies experience the joys of vanilla #HTML#CSS#JavaScript and #WebComponents! (with a sprinkle of lightweight tools to smooth out the bumps in the road ☺️)
Hey y'all, a new #fediverse social web forum is in da house!! 🎉
Talk learning #WebDev from base principles and help fellow newbies experience the joys of vanilla #HTML#CSS#JavaScript and #WebComponents! (with a sprinkle of lightweight tools to smooth out the bumps in the road ☺️)
A grumpy ItSec guy walks through the office when he overhears an exchange of words.
dev0: Big news - we finally upgraded every framework to the latest. dev1: And the pipeline looks good: SAST, container scan, DAST... all green. dev0: ItSec won't have anything to nitpick now!
ItSec (walking by): ... and BAC? dev0: BAC? ItSec: Broken Access Control [1]. Did you actually test for it?
dev1: What's he on about this time?
Let's learn by example: imagine an endpoint that returns a specific invoice.
GET /api/invoices/123 Authorization: Bearer <token-for-user-A>
User A legitimately fetches invoice 123. Now change only the ID:
GET /api/invoices/124 Authorization: Bearer <token-for-user-A>
If the app returns 200 with User B's data, you've got Broken Access Control (aka IDOR).
Access control enforces who can do what on which resource. When it's broken, attackers can act outside their permissions: read others data, modify or delete it, or trigger business functions they shouldn't. In practice, this often comes from missing server-side checks that tie the caller to the resource owner (or an allowed role).
Why your shiny scanners may have missed it:
1) SAST sees code patterns, not ownership semantics (it can't deduce "invoice 124 belongs to User B"). 2) DAST usually crawls with one session; it rarely performs cross-identity trials (User A poking at User B's data). 3) CI/CD "green checks" mean dependencies, images, and common vulns look fine - not that your authorization logic is correct.
What can you do?
1) Enforce checks on the server (never rely on the client): before every read/update/delete, verify the caller is the owner or has a permitted role. 2) Centralize authorization in a service/middleware. 3) Prefer opaque, unguessable IDs (UUIDs) over sequential integers, but still enforce server checks (UUIDs are not security). 4) Deny by default. Make allow-lists explicit.
ALT text detailsFirst option is elem.setAttribute('data-visible', attrs.includes(market) ? 'true' : 'false');
Second option is elem.setAttribute('data-visible', String(attrs.includes(market)));
The new integrated Markdown parser I’ve been implementing in Kitten has been kicking my ass for the past few weeks but I think I finally have it fully working and seamlessly so. Expect a new release this/next week that brings the parsing of Markdown pages (.page.md files) in your apps up to the standard of the recently-improved runtime Markdown parsing in Kitten HTML tagged-template strings (within `<markdown>…</markdown>` blocks).
The coolest thing is I was able to implement this without introducing any new syntax. In fact, I was able to simplify things so that you can now add arbitrary JavaScript to your Markdown pages within a multi-line script block in the YAML front matter (`script: |`) and use JavaScript string interpolation syntax in your Markdown (and, of course, Kitten components and conditionals, which, themselves, rely on string interpolation).
The only place where you have to deviate from standard Markdown in your Markdown pages is if you have JavaScript string interpolations or Kitten components/conditionals in code fences within your Markdown. In that case, you’ll have to escape them (e.g., `<\${Component} />`, `\<if \${something}>something\</if>`, etc.). And, to be fair, the person most impacted by this is likely me as the Kitten documentation at https://kitten.small-web.org is written in Kitten so I had a lot of escaping to do. But for any other use case, it means that things should just work and work exactly as they do in JavaScript pages (page.js files).
Anyway, so this is going to be a breaking change so I thought I’d give you (the three of you playing with Kitten right now?) a heads up. Of course, I’ll be updating the documentation to reflect all this.
(Remember, Kitten is in pre-release and it’s the framework I’m building/using to create Catalyst – the Small Web hosting solution – and Yarn – a small web – peer to peer – personal site app. So Kitten isn’t the means, not the end. And, at least until the Version 1 API freeze, things can and will break. That said, there’s nothing stopping you from playing with it now and, to be fair, at this point, such breaking changes should become rarer and rarer).
Version 2.4 of "Famsite", my self-hosted social media site, now features my Faceclick Emoji picker. (I'll be releasing Faceclick itself soon, I just need to finish the README.)
The Emoji picker more than doubled the size of the project, it's over 100Kb now. But hey, you can still fit 10 copies on a floppy! 💾
Also note that 2.1 added the grouping of daily word game result comments, a huge improvement for _my_ family. 😃
ALT text detailsScreenshot of Ratfactor's Famsite social media for friends and family. Screenshot shows an image thumbnail for uploading, an emoji picker, a normal comment, and grouped comments with daily word game results.
ALT text detailsScreenshot of Node.JS REPL with three commands run:
1. Object.entries(result) returns a single key/value pair: "property" equals "object!".
2. Invoking result() as a function returns a string "function!".
3. awaiting result directly returns string "promise!".
"Trust your research. Trust your choices. Don’t tinker. Don’t micromanage. Don’t panic. Just let the compounding effects of a good choice work in your favor."
Another step in my path to revitalize usage of XSLT on the web. And before you ask, no, this is not to spite the #WHATWG and their #XML-aversive #JavaScript brainrot, it's something I've wanted to do for years, as documented by my previous posts on the subject.
However, since the corporate-controlled WHATWG is using metrics as excuse to boycott the #openWeb and #indieWeb, it becomes doubly important to do this now.
Another step in my path to revitalize usage of XSLT on the web. And before you ask, no, this is not to spite the #WHATWG and their #XML-aversive #JavaScript brainrot, it's something I've wanted to do for years, as documented by my previous posts on the subject.
However, since the corporate-controlled WHATWG is using metrics as excuse to boycott the #openWeb and #indieWeb, it becomes doubly important to do this now.
Signals, a reactive primitive popularized by many #JavaScript frameworks and libraries, makes it much easier to add declarative binding to your #HTML using basic vanilla DOM techniques + signal effects.
I haven’t had a concrete example to show off just how simple yet powerful this can be…until now! 😎
Here's the ubiquitous counter demo, todo list with a completion count, and typewriter printing out a message—all with a binding solution in only 20 lines of code! #WebDev
Signals, a reactive primitive popularized by many #JavaScript frameworks and libraries, makes it much easier to add declarative binding to your #HTML using basic vanilla DOM techniques + signal effects.
I haven’t had a concrete example to show off just how simple yet powerful this can be…until now! 😎
Here's the ubiquitous counter demo, todo list with a completion count, and typewriter printing out a message—all with a binding solution in only 20 lines of code! #WebDev
ALT text detailsScreenshot of Node.JS REPL with three commands run:
1. Object.entries(result) returns a single key/value pair: "property" equals "object!".
2. Invoking result() as a function returns a string "function!".
3. awaiting result directly returns string "promise!".
(Fun fact: had #ActivityPub been designed around an #XML representation of linked data instead of #JSON, most of the #Fediverse could be presented on the web via #XSLT, without requiring #JavaScript, directly from the source objects.)
If I choose a helper library like #LitHtml and make some component. Say like a button. And I want to make it portable to different projects / contexts.
Is it possible with some tool to "compile" it back to a vanilla web-component again? Or would it only be "portable" to some other context if you also handed over the dependency on Lit?
Fedify is an #ActivityPub server framework in #TypeScript & #JavaScript. It aims to eliminate the complexity and redundant boilerplate code when building a federated server app, so that you can focus on your business logic and user experience.
The key features it provides currently are:
Type-safe objects for Activity Vocabulary (including some vendor-specific extensions)
I do not want to install any NPM package without an organization namespace. I can evaluate the security practices of an organization more easily than every commit on a repo (especially in monorepos) to evaluate a package.
🚨 New research: North Korea’s Contagious Interview campaign is back, with 67 new malicious npm packages, a new malware loader (XORIndex), and 17K+ downloads.
🚨 New research: North Korea’s Contagious Interview campaign is back, with 67 new malicious npm packages, a new malware loader (XORIndex), and 17K+ downloads.
Here's how I see people based on their choice of API programing language.
#JavaScript: You don't care about anything else then the engineer pool you can employ so you take the default one. You're the basic b*.
#csharp: You're a Cpp programmer that only want to use the closest relative. You don't like change.
#elixir: You're the kind of person to read every articles on a subject to take a decision. What you want is nothing the objective best. Your vim is better then theirs. You know you have no recruitment pool but it doesn't matter, you're a 100x developer and nobody could understand how brilliant your code is anyway. You're an hipster
#pyhon: You created your startup to be sold. You basically want a great demo fast, get an offer and gtfo.
#ruby: it's been 10 years you didn't talk to anyone. You got in the hipe and never realised that everyone moved on except you.
#golang: You wish you could use elixir but settled for the second best for none technical reasons. You're submissive. Google is your master.
Hi! I’m Wan Ching. I started coding in 2012 with #JavaScript, #Python, and #jQuery. Over the years, I’ve dived into #React, #TypeScript, and now #LLMs. They’re #ToolsNotMagic, and can never replace thinking. 💡 Fundamentals still matter. I’m always excited to learn and grow with every new tool.
I understand it is customary to #Introduction myself.
#OpenSource#Software Saving Internet From#AI Bot #Scrapers #Anubis, which block AI scrapers from scraping websites to death, has been downloaded 200,000 times. "It uses features of your browser to automate a lot of the work that a CAPTCHA would, and right now the main implementation is by having it run a bunch of cryptographic math with JavaScript to prove that you can run #JavaScript in a way that can be validated on the server." Verifies you are human using a browser. https://www.404media.co/the-open-source-software-saving-the-internet-from-ai-bot-scrapers/
#OpenSource#Software Saving Internet From#AI Bot #Scrapers #Anubis, which block AI scrapers from scraping websites to death, has been downloaded 200,000 times. "It uses features of your browser to automate a lot of the work that a CAPTCHA would, and right now the main implementation is by having it run a bunch of cryptographic math with JavaScript to prove that you can run #JavaScript in a way that can be validated on the server." Verifies you are human using a browser. https://www.404media.co/the-open-source-software-saving-the-internet-from-ai-bot-scrapers/
YouTube is now recommending me a bunch of videos of people making their own cute little HTML websites, usually on Neocities or what they are calling The Indie Web and its giving me hope.
I knew this was a thing, and I knew people are still making websites like this, but it's really fun to see people encouraging people to do the same or making tutorials on YouTube.
YouTube is now recommending me a bunch of videos of people making their own cute little HTML websites, usually on Neocities or what they are calling The Indie Web and its giving me hope.
I knew this was a thing, and I knew people are still making websites like this, but it's really fun to see people encouraging people to do the same or making tutorials on YouTube.
🌸 Floral Sample Toolkit is underway, and I'm almost at 10 algorithms in there. Will be using this in my next track, and will make the repo public at the same time!
As you can see, the "Trace Console" logs each step you take, and then exports that along with the final WAV. That way you can do destructive editing, but still share the steps in an open-source sense 😀
🌸 Floral Sample Toolkit is underway, and I'm almost at 10 algorithms in there. Will be using this in my next track, and will make the repo public at the same time!
As you can see, the "Trace Console" logs each step you take, and then exports that along with the final WAV. That way you can do destructive editing, but still share the steps in an open-source sense 😀
It's been 30 years we have #Javascript. So much in technology has changed in that time. It's kind of amazing how much the language and the broader web helped shape the world.
#deno post on the history of Javascript really cements this. Can't believe it's been that long. 😅
It's been 30 years we have #Javascript. So much in technology has changed in that time. It's kind of amazing how much the language and the broader web helped shape the world.
#deno post on the history of Javascript really cements this. Can't believe it's been that long. 😅
Okay, one more #TypeScript hater post: override functions are useless. Their selling point is that you can provide multiple (supposedly compatible) signatures for a function and then process whatever comes in being certain of its type. Except... it only allows one implementation body. So you may have five override signatures, but only one implementation function. And this implementation is doomed to re-invent type/value dispatching, even though TS was supposed to help. To illustrate, here's a simple "take string or int, convert it to int, and print it out" function in #CommonLisp, #JavaScript, and #typescript
(defmethod foo ((x integer)) (format t "~&X is ~d~%" x))
-----------------------------------
function foo (x) { if (typeof x === "string"){ foo(parseInt(x)); } else { console.log("X is " + x) } }
------------------------------------
function foo(x: number): void; function foo(x: string): void; function foo(x: string | number): void { if (typeof x === "string") { console.log("X is " + parseInt(x)); } else { console.log("X is " + x); } }
- CL generic function is short and strictly typed. - JS function is short-ish and does its own type dispatching. - TS function is LONG and DOES ITS OWN TYPE DISPATCHING. Useless, in other words.
Are you ready to rewrite your whole application every 2 years? Choose Remix/Remix2/ReactRouter7/Remix3, what is stability? & remember old bugs don't exist if you rewrite constantly 🧠
Just shared my thoughts on #JavaScript library #logging on Hacker News. Explores the fragmentation problem and dependency dilemmas from a library author's perspective. Would love to hear feedback from the #winston/#Pino users.
Just shared my thoughts on #JavaScript library #logging on Hacker News. Explores the fragmentation problem and dependency dilemmas from a library author's perspective. Would love to hear feedback from the #winston/#Pino users.
#web#javascript Cet article est absolument parfait: Il cristallise tout ce qui me fait techniquement VOMIR le web tel qu'il est actuellement, aussi bien en tant qu'utilisateur du web qu'en tant que développeur.
#web#javascript Cet article est absolument parfait: Il cristallise tout ce qui me fait techniquement VOMIR le web tel qu'il est actuellement, aussi bien en tant qu'utilisateur du web qu'en tant que développeur.
R と G と B は知覚への寄与度が異なるから、各チャンネルに割り当てる階調数を変えて節約する場合があるけど、最小値と最大値を固定して刻む方法では無彩色の灰色が得られないという課題がある。ぢゃあ灰色が作れる事を優先して、飽和した色が得られる事には こだわらず、なるべく知覚的に均等に近いパレットを作ったらどうなるか試しました。
R と G と B は知覚への寄与度が異なるから、各チャンネルに割り当てる階調数を変えて節約する場合があるけど、最小値と最大値を固定して刻む方法では無彩色の灰色が得られないという課題がある。ぢゃあ灰色が作れる事を優先して、飽和した色が得られる事には こだわらず、なるべく知覚的に均等に近いパレットを作ったらどうなるか試しました。
Recently I've combined various functions which I've been using in other projects (e.g. my personal PKM toolchain) and published them as new library https://thi.ng/text-analysis for better re-use:
The attached code example (also in the project readme) uses this package to creeate a clustering of all ~210 #ThingUmbrella packages, based on their assigned tags/keywords...
The library is not intended to be a full-blown NLP solution, but I keep on finding myself running into these functions/concepts quite often, and maybe you'll find them useful too...
ALT text detailsCommented and syntax-highlighted TypeScript source code/example from the project readme, showing different steps, transformations and analysis results and how to create a k-means clustering of 200+ projects
"Look, I don't think there's anything wrong with programming in #python or #javascript, but you should probably switch to #haskell when you hit like 3 or 4 months of experience
"Look, I don't think there's anything wrong with programming in #python or #javascript, but you should probably switch to #haskell when you hit like 3 or 4 months of experience
Vitest 3.2 is out! - New Annotations API - Scoped Fixtures - Custom Browser Locators API - Test Signal - Better V8 Coverage Result And many more features!
My employer, after 7 months of work, fired me overnight. Because I would be too "finicky" about code quality and security risks, which would better suit "a bank or cybersecurity company".
My employer, after 7 months of work, fired me overnight. Because I would be too "finicky" about code quality and security risks, which would better suit "a bank or cybersecurity company".
Mon employeur, après 7 mois de période d'essai, vient de la rompre du jour au lendemain. Parce que je serais trop "pointilleuse" sur le code et les risques de sécurité, ce qui conviendrait mieux au secteur "de la banque ou de la cybersécurité".
My employer, after 7 months of work, fired me overnight. Because I would be too "finicky" about code quality and security risks, which would better suit "a bank or cybersecurity company".
Mon employeur, après 7 mois de période d'essai, vient de la rompre du jour au lendemain. Parce que je serais trop "pointilleuse" sur le code et les risques de sécurité, ce qui conviendrait mieux au secteur "de la banque ou de la cybersécurité".
Vitest 3.2 is out! - New Annotations API - Scoped Fixtures - Custom Browser Locators API - Test Signal - Better V8 Coverage Result And many more features!
#ReleaseTuesday — New version of https://thi.ng/tsne with ~15-20% better performance[1] due to avoiding repeated internal allocations and skipping gradient updates where unnecessary...
[1] Benchmarked with multiple datasets of ~750 items, each with 192 dimensions (now ~165ms @ MBA M1, 2020)...
Vitest 3.2 is out! - New Annotations API - Scoped Fixtures - Custom Browser Locators API - Test Signal - Better V8 Coverage Result And many more features!
Vitest 3.2 is out! - New Annotations API - Scoped Fixtures - Custom Browser Locators API - Test Signal - Better V8 Coverage Result And many more features!
Vitest 3.2 is out! - New Annotations API - Scoped Fixtures - Custom Browser Locators API - Test Signal - Better V8 Coverage Result And many more features!
#ReleaseMonday — New version (v0.27.0) of https://thi.ng/genart-api, a platform-independent extensible API for browser-based computational/algorithmic/generative art projects:
This version features an overhaul of the platform provided PRNG (pseudo-random number generator) handling and makes it easier to create multiple PRNGs for artworks which require/desire them...
- no external dependencies - adapters for 3 art platforms (EditArt, fxhash, Layer) - 6 example projects - testing/dev sandbox with two parameter editors - WebAssembly bindings & demo (currently for #Zig only)
No-as-a-Service (NaaS) is a simple API that returns a random rejection reason. Use it when you need a realistic excuse, a fun “no,” or want to simulate being turned down in style. – from @hothead
I have a low-vision student who is learning to code JavaScript. She needs a better code editor to work with, and/or some plugins to make it work better with her screen readers. What do the accessible developers recommend? **#accessibility** **#screenreader#javascript**
I have a low-vision student who is learning to code JavaScript. She needs a better code editor to work with, and/or some plugins to make it work better with her screen readers. What do the accessible developers recommend? **#accessibility** **#screenreader#javascript**
I gotta say, I'm kinda enjoying writing JS in this "JSDocScript" mode 🤔 The code is almost* unchanged except the comments - I really wanted to avoid complicating it or adding more instructions just for the types - but I get most of the advantage of TS in much more confident and faster refactoring.
Mithril.js seems nice so far. It's a rare example of a framework that's just finished: still in use but not updated. This leads to the impression that it's abandoned, though, which means the ecosystem around it has decayed a bit.
In particular, I was using Storybook in my Svelte version of this project, and a Storybook adapter for Mithril used to exist... but it was removed after v6. (current Storybook major version is 8).
I've been trying different frontend JS frameworks in some of my projects, and I'm... not as impressed with Svelte as I thought I'd be.
I've heard constant praise for this framework, and it is technically impressive, but there's just so much magic. Svelte 5 uses built-in not-quite-functions called runes, like $state or $derived, to mark certain variables as reactive state. When something reactive is updated, components redraw; otherwise, they don't. And when they don't, it's often very hard to figure out why. Plus the usual problems of the Vue-style component files: components aren't first-class objects, you have to put them in their own files, there's no JSX, etc.
I've written a lot of React, and React hooks are magical too, but this seems worse. Does it just feel that way because I've taken the time to get used to how React does things?
Maybe I'd use Svelte again on a project with (ironically) less reactivity, but my chat app uses websockets and indexeddb and lots of event streams, and Svelte just keeps getting in the way.
I'm considering trying Mithril.js next, which is, philosophically, the exact opposite. Sounds like a breath of fresh air.
https://plainvanillaweb.com is a cool, simple site that shows and tells you how to de-framework. Useful info today in a world or gunked-up, cluttered, crappy and overly complicated websites.
#ReleaseSaturday — Just added 35 new color palettes (255 in total now) to https://thi.ng/color-palettes. All of these are based on images and dominant colors have been extracted via this tool below and then partially hand edited. The SVG swatches were generated via a custom tool (included in the project repo).
The package provides accessors for obtaining themes as CSS hex colors, RGB or LCH tuples. Themes can also be programmatically selected/filtered by a number of composable criteria (examples in the readme)...
ALT text detailsExcerpt from the package readme, showing a table of 18 newly added color themes, each consisting of 6 colors and visualized as 6 swatches.
ALT text detailsExcerpt from the package readme, showing a table of 17 newly added color themes, each consisting of 6 colors and visualized as 6 swatches.
Last weekend I published a fun little project that allows you to use the #Rust library #Ratatui to make a #TUI (Terminal UI) in #JavaScript/#TypeScript, via #WASM.
Last weekend I published a fun little project that allows you to use the #Rust library #Ratatui to make a #TUI (Terminal UI) in #JavaScript/#TypeScript, via #WASM.
This day 30 years ago, a new employee at Netscape named Brendan Eich was hard at work creating a web scripting language called Mocha. It would soon be re-named JavaScript, in a dubious attempt to co-brand it with another new web programming language from May 1995, Java. https://cybercultural.com/p/1995-the-birth-of-javascript/
This day 30 years ago, a new employee at Netscape named Brendan Eich was hard at work creating a web scripting language called Mocha. It would soon be re-named JavaScript, in a dubious attempt to co-brand it with another new web programming language from May 1995, Java. https://cybercultural.com/p/1995-the-birth-of-javascript/
🚨 The Socket Threat Research Team has discovered a set of malicious npm packages targeting macOS developers using the Cursor AI code editor. They steal credentials, disable updates, and add a persistent backdoor to the IDE.
🚨 The Socket Threat Research Team has discovered a set of malicious npm packages targeting macOS developers using the Cursor AI code editor. They steal credentials, disable updates, and add a persistent backdoor to the IDE.
When you’re scripting for a screen reader, then you’re scripting for the browser, with exactly the same level of JavaScript support.
However complications can arise with event handling, because screen readers intercept events and don't always pass them on to the browser, and even then, keyboard actions might fire mouse events.
AIMindUpdate News! 🚀⚡️ Great news for Deno developers! 2.3 update brings faster compiles, local NPM support, and much more. Boost your workflow! #Deno#JavaScript#TypeScript
AIMindUpdate News! 🚀⚡️ Great news for Deno developers! 2.3 update brings faster compiles, local NPM support, and much more. Boost your workflow! #Deno#JavaScript#TypeScript
The site loads and I see a search field, then I type in my search term. The client JavaScript hydrate the search form and clear my previously-entered search term. Now I need to type it again. Welcome to "modern web". #webdev#a11y#JavaScript
@zef#lua is one of the few languages I've kept using for decades. It's a simple enough, but immensely powerful. What we should've gotten for the web instead of #Javascript. 😏
The one data structure grew on me. I kind of miss it when I'm not using the language. Cause you can do practically anything you need. And with metatables, you can make data structures function exactly how you need. With guards and limits to your heart's desire. 😅
When you’re scripting for a screen reader, then you’re scripting for the browser, with exactly the same level of JavaScript support.
However complications can arise with event handling, because screen readers intercept events and don't always pass them on to the browser, and even then, keyboard actions might fire mouse events.
#ReleaseWednesday 🚀 — I wonder how many other FLOSS devs are sitting on code for ~8 years prior to first release... In one of these cases (many others readily available in my stash 🙃), triggered by recent major updates to the thi.ng/vectors library, I've refactored (almost 100% rewritten) and applied the same approach to the new/old package:
This package provides 1D/2D/3D/4D tensors, supporting different storage implementations (currently still all CPU side only) and an extensible set of polymorphic tensor operations (currently ~45 math ops, incl. matrix-matrix/matrix-vector products, reductions, argmin/max, activation functions etc.). The tensor classes themselves also provide several zero-copy slicing, re-ordering, clipping, extraction functions, most of them type-safe.
The original (private) version was heavily reliant on dynamic code generation, which has now been replaced with higher-order functions to provide various dimension-optimized versions of all operations.
This package is NOT specifically aimed at machine learning, even though it could probably used for some tasks in that realm (likely with extra hand holding). There are many other use cases for this kind of data structure...
Also new in other packages in this release cycle (incl. some code examples):
Working on some things... This uses a version of the context protocol for binding updates. All you have to do to implement your own bindings is listen for an even and call a callback
I'm definitely having fun hacking away at #silverbullet. 😄
Right now, getting used to using the #javascript import. Which can effectively pull almost any js module. And with #jsr being a thing... let's just say silverbullet instance is going to get weird. 😅
I'm honestly surprised it took this log to learn of this gem. Likely due to my still very much liking #logseq. Although... give me a few weeks... I'll likely build my own journaling system on this thing. 😇
I'm definitely having fun hacking away at #silverbullet. 😄
Right now, getting used to using the #javascript import. Which can effectively pull almost any js module. And with #jsr being a thing... let's just say silverbullet instance is going to get weird. 😅
I'm honestly surprised it took this log to learn of this gem. Likely due to my still very much liking #logseq. Although... give me a few weeks... I'll likely build my own journaling system on this thing. 😇
Sometimes my follower count seemingly fluctuates at random. To understand why, I dug into the #MastodonAPI and created "fedi-followers":
A privacy-friendly #fediverse#followers explorer as local-only static web app, decentrally hosted on the #ipfs. See who's actually following (and unfollowing) you over time and much more.
Sometimes my follower count seemingly fluctuates at random. To understand why, I dug into the #MastodonAPI and created "fedi-followers":
A privacy-friendly #fediverse#followers explorer as local-only static web app, decentrally hosted on the #ipfs. See who's actually following (and unfollowing) you over time and much more.
@parksb 안녕하세요 오픈 소스에 관심있는 개발자입니다! 자정되면서 맞지 않는 부분은 어떤게 있을까요? 🤔 yarn-plugin-catalogs가 pnpm catalog 기능을 yarn에도 확장 시킨것 같은데 이런 부분에서 안맞는게 있는걸까요? #Yarn#pnpm#javascript
Added a new convenience transducer for clipping and binning values, e.g. as preparation step for histogram generation whilst working in the REPL. New release forthcoming. A small code example attached (actually taken from the doc string of the new `binned()` transducer).
ALT text detailsScreenshot of syntax-highlighted TypeScript source code to compute histogram of 1 million gaussian random samples (aka normal distribution), using binned values and discard those outside configured interval. The histogram is then sorted by (bin) position and the values plotted as ANSI-art diagram
"*BOSS (Big Open Source Sibling) é uma iniciativa de mentoria que visa engajar grupos sub representados na tecnologia para que comecem a contribuir para comunidades Open Source.
Nessa mentoria, muito mais do que desenvolver habilidades técnicas, as participantes aprendem competências úteis às comunidades Open Source, como se comunicar, trabalhar de forma assíncrona e remota, desenvolver coletivamente, etc."
"*BOSS (Big Open Source Sibling) é uma iniciativa de mentoria que visa engajar grupos sub representados na tecnologia para que comecem a contribuir para comunidades Open Source.
Nessa mentoria, muito mais do que desenvolver habilidades técnicas, as participantes aprendem competências úteis às comunidades Open Source, como se comunicar, trabalhar de forma assíncrona e remota, desenvolver coletivamente, etc."
I'm so annoyed that in JavaScript it's 'getElementsByClassName' instead of just 'getElementsByClass' Why adding Name? There's no getElementsByClassSurname or getElementsBySocialClass anyways!
• New: Lovely new icons¹ and new callouts in Kitten Settings²
• New: Markdown now supports attributes and bracketed spans³
• New: client-side `kitten` global with `trigger` function for triggering events on the server from the client. (Useful when streaming client-side JavaScript when using Kitten’s Streaming HTML⁴ workflow. e.g., when you have to use a client-only web API like the Clipboard API but you want to keep all your logic on your server-side page.⁵)
• Fixed: The bound render function returned by `KittenComponent` class’s `component` getter now correctly awaits asynchronous templates. (In Kitten, you don’t have to care whether your templates contain promises. Kitten handles all that for you.)
• New: Lovely new icons¹ and new callouts in Kitten Settings²
• New: Markdown now supports attributes and bracketed spans³
• New: client-side `kitten` global with `trigger` function for triggering events on the server from the client. (Useful when streaming client-side JavaScript when using Kitten’s Streaming HTML⁴ workflow. e.g., when you have to use a client-only web API like the Clipboard API but you want to keep all your logic on your server-side page.⁵)
• Fixed: The bound render function returned by `KittenComponent` class’s `component` getter now correctly awaits asynchronous templates. (In Kitten, you don’t have to care whether your templates contain promises. Kitten handles all that for you.)
Unicopedia Anatolica is a developer-oriented set of #Unicode utilities related to Anatolian hieroglyphs, wrapped into one single app, built with #Electron.
Unicopedia Anatolica is a developer-oriented set of #Unicode utilities related to Anatolian hieroglyphs, wrapped into one single app, built with #Electron.
ALT text detailsA screenshot of a code editor displaying JavaScript code related to handling keyboard shortcuts and column navigation.
The keyboard shortcuts '[' and ']' will flip based on RTL setting.
ALT text detailsA screenshot of a code editor displaying JavaScript code related to handling keyboard shortcuts and column navigation.
The keyboard shortcuts '[' and ']' will flip based on RTL setting.
ALT text detailsA screenshot of a code editor displaying JavaScript code related to handling keyboard shortcuts and column navigation.
The keyboard shortcuts '[' and ']' will flip based on RTL setting.
ALT text detailsA screenshot of a code editor displaying JavaScript code related to handling keyboard shortcuts and column navigation.
The keyboard shortcuts '[' and ']' will flip based on RTL setting.
• Fixes #236¹: The data preview pages in Kitten’s settings how handle circular references in the deserialised data (which may contain your custom classes if that’s what you were persisting in the database).
PS. Those pages are very rudimentary at the moment and are good for getting quick visual overview of the data you’re persisting. For a fully interactive view, use Kitten’s interactive shell (REPL)² to explore your data until I’ve had a chance to implement a more comprehensive visual interface.
PPS. You persist data in Kitten using the built-in JavaScript Database (JSDB)³ (Or, of course, you can install and use any other database.)
• Fixes #236¹: The data preview pages in Kitten’s settings how handle circular references in the deserialised data (which may contain your custom classes if that’s what you were persisting in the database).
PS. Those pages are very rudimentary at the moment and are good for getting quick visual overview of the data you’re persisting. For a fully interactive view, use Kitten’s interactive shell (REPL)² to explore your data until I’ve had a chance to implement a more comprehensive visual interface.
PPS. You persist data in Kitten using the built-in JavaScript Database (JSDB)³ (Or, of course, you can install and use any other database.)
Configuring a complex tool can take more work that just coding the functionality from scratch. Earlier I created a simple blog in #Astro, a popular #SSG. That felt more complicated than the problem justified, so I rewrote the entire #blogging project from scratch in pure JavaScript with 0 dependencies.
This went very well!
ALT text detailsChart comparing size of source code of 22K for zero dependency version and 11K for Astro version
ALT text detailsChart comparing 0 node_modules for zero dependency and 117Mb for Astro version
Configuring a complex tool can take more work that just coding the functionality from scratch. Earlier I created a simple blog in #Astro, a popular #SSG. That felt more complicated than the problem justified, so I rewrote the entire #blogging project from scratch in pure JavaScript with 0 dependencies.
This went very well!
ALT text detailsChart comparing size of source code of 22K for zero dependency version and 11K for Astro version
ALT text detailsChart comparing 0 node_modules for zero dependency and 117Mb for Astro version
#ReleaseWednesday — I just released a new version (v8.0.0) of https://thi.ng/vectors, an almost complete rewrite of the package with all of its ~900 vector operations. I've updated the Readme with a section of _potentially_ minor breaking changes, however I expect this to be a seamless upgrade for the vast majority of users...
I've recently written more about the reasons and implications of this update and I'll refer you to those posts instead of repeating them once more (see links below).
Just the top-level changes:
- Replaced dynamic code generation with higher-order templating to be usable with strict content security policies (when deployed online) - New structure allows for vast majority of functions to have doc strings (and they do now) - More consistent/less confusing naming for some operations - Potentially improved tree-shaking and smaller project bundle sizes
Related to this update I've also refactored and fixed some bugs in other packages (e.g. color, geom, matrices). As a result both the color & matrix packages are now also free from dynamic codegen and therefore won't cause any problems with strict CSPs
Should you run into any issues regarding this update, please get in touch (also grateful for any other experience/impact reports... 🙏)
Just added some new diagrams to describe the internals of the https://thi.ng/block-fs block storage & filesystem (incl. some examples) and also added/updated CLI tooling docs...
ALT text detailsScreenshot excerpt of the https://thi.ng/block-fs readme, showing the section & diagrams about file system data layouts and internals.
ALT text detailsScreenshot excerpt of the https://thi.ng/block-fs readme, showing the section about the command line tool (incl. terminal output). The first example shows how to convert a file tree from the host system into a single binary blob, the second command example shows how to list files/directories from such a blob
Unicopedia Ægypta is a developer-oriented set of #Unicode utilities related to Egyptian hieroglyphs, wrapped into one single app, built with #Electron.
To put the "large" package size a little more into perspective: I don't know of any other feature-comparable JS vector library which provides all of the following:
- Generic n-dimensional float, int, uint, boolean vectors - Size optimized versions for 2D/3D/4D (all types) - Multiple-dispatch wrappers (auto-delegating to available optimized versions) - Memory-mapped vectors and optimized versions for various memory layouts (e.g. SOA/AOS) - Optimized versions of many vector-scalar ops - Optimized compound operations (like multiply-add etc.) - Vector randomizations (several approaches) - 99% of GLSL vector operations & conversions - Vector versions of most of JS `Math` ops - Vector interpolations (linear, bilinear, cubic, quadratic...) - 10 different distance functions & metrics - Swizzling & vector coercion/extension - Dozens of additional graphics, statistics & ML-related operations
Just a quick #ThingUmbrella update to say that I've already replaced the https://thi.ng/vectors package on the develop branch and after LOTS of deep experimentation have decided NOT to split up the package. There will be a few (minor) breaking changes, mainly because of enforcing more consistent naming and more granularity in some source files (therefore possibly changed imports, though only if you use direct ones for individual functions...). All in all, I've managed to keep the impact on users to a bare minimum (likely unnoticeable for most), even though it's pretty much a complete rewrite of the entire package (with all its ~900 functions)... This package is now almost 10 years old and I'm very happy how this refactor turned out!
In terms of file size impact: The FULL minified pkg bundle is now 56.4KB vs previously 48.5KB, however the code density has improved and the brotli-compressed pkg size is only 15.1KB (only 1KB larger than before), which I found absolutely incredible! 🎉 I also have to state once more that this package (and most others in #ThingUmbrella) are _designed for tree shaking_ and bundling. Hardly any project would ever use the full set of functions provided here all at once, most will only use a small/tiny subset...
Also — more importantly — many of the 185 example projects in the repo are now showing between 2-25% smaller final bundle sizes. Some also have become slightly larger, but so far I found the most by only ~2%...
Related to this change: I've also updated the https://thi.ng/color & https://thi.ng/matrices packages to be free from dynamic code generation now! The only packages still using `new Function(...)` are the following, but for those it's unavoidable and dynamic code generation is a core feature:
In recent years every spring seems to turn into a period of _massive_ refactoring & restructuring in #ThingUmbrella — maybe it's a form of spring cleaning, even though the reasons[1] are not seasonal... Currently spending my nights reworking the https://thi.ng/vectors package (likely one of the most comprehensive vector packages available for TS/JS) and trying out different splits/structures, testing their impact on package sizes and usability in existing downstream packages. Currently over 3000 source files with uncommitted changes... aaaarrrgghh! 🤯
Most functions (vector operations) in this package exist in multiple versions (many code generated, but now in need to be updated): Generic n-dimensional, loop-free, optimized 2D/3D/4D versions and strided versions for manipulating vectors views of larger nD data buffers (supporting all kinds of data layouts, incl. AOS, SOA, hybrid...)
Fedify is an #ActivityPub server framework in #TypeScript & #JavaScript. It aims to eliminate the complexity and redundant boilerplate code when building a federated server app, so that you can focus on your business logic and user experience.
The key features it provides currently are:
Type-safe objects for Activity Vocabulary (including some vendor-specific extensions)
An e-commerce web application of my authorship built using SQL Server, EF, ASP. NET Core MVC, C#, Javascript and an assortment of other libraries and web services.
Data analysis in Jupyter notebooks with... TypeScript?! 😱 ✅ using `fetch` and other web standards ✅ fast dataframes with nodejs-polars ✅ easy charts with @observablehq ✅ rich interactive UIs with JavaScript
Dnes otázka od bývalého kolegy: "a proč se zase učíš #JavaScript, když se vším už pomůže AI?" Zároveň mě informoval, že vytváří mobilní aplikaci ve Flutteru pomocí ChatGPT (podotýkám, že on sám nemá žádné programátorské zkušenosti). Svět je už v háji... #dobaKonce
#ReleaseWednesday Just pushed a new version of https://thi.ng/block-fs, now with additional multi-command CLI tooling to convert & bundle a local file system tree into a single block-based binary blob (e.g. for bundling assets, or distributing a virtual filesystem as part of a web app, or for snapshot testing, or as bridge for WASM interop etc.)
Also new, the main API now includes a `.readAsObjectURL()` method to wrap files as URLs to binary blobs with associated MIME types, thereby making it trivial to use the virtual filesystem for sourcing stored images and other assets for direct use in the browser...
ALT text detailsScreenshot excerpt from the project readme (link in post) containing information about the CLI wrapper, as well as example usage (here to convert/bundle as filesystem tree)
ALT text detailsScreenshot excerpt from the project readme (link in post) containing information about the CLI wrapper, as well as example usage (here to list contents of an already bundled filesystem)
Data analysis in Jupyter notebooks with... TypeScript?! 😱 ✅ using `fetch` and other web standards ✅ fast dataframes with nodejs-polars ✅ easy charts with @observablehq ✅ rich interactive UIs with JavaScript
I'm working on a project that is intended to encourage folk to make markdown text files which can be bundled together in different bundles of text files using a package manager.
Question for coders; Which package manager would you suggest I use?
Main criterias (in order) are:
1. Easy for someone with basic command line skills to edit the file and update version numbers and add additional packages.
2. All being equal, more commonly and easy to setup is preferred.
Do you have any suggestions, tips, opinions, dos, don’ts about headless CMSes?
I have a growing list of small/mid non-profits and collectives asking for my help to (re)make their website. I totally want to help, but I don’t have much time, especially considering that they generally have little or no funding—I would most definitely point them to @VillageOneCoop, otherwise.
Therefore, I want a super simple and replicable solution where I can copy-paste most of the code, while providing them with a stable, fast, and modern solution. I had a look at the Headless CMS section in the Jamstack website, but I need opinions from people who actually used some of that software already.
Needs
I want to code and configure everything using @eleventy
Admin interface (#WebApp) for the client to add pages and write posts
Static website in the front-end
Simple and reliable CI/CD
No/minimal maintenance after the first setup
Self-hostable (I was taking this for granted so much that I forgot to write it)
If it requires forge integration, it should support #ForgeJo
Do you have any suggestions, tips, opinions, dos, don’ts about headless CMSes?
I have a growing list of small/mid non-profits and collectives asking for my help to (re)make their website. I totally want to help, but I don’t have much time, especially considering that they generally have little or no funding—I would most definitely point them to @VillageOneCoop, otherwise.
Therefore, I want a super simple and replicable solution where I can copy-paste most of the code, while providing them with a stable, fast, and modern solution. I had a look at the Headless CMS section in the Jamstack website, but I need opinions from people who actually used some of that software already.
Needs
I want to code and configure everything using @eleventy
Admin interface (#WebApp) for the client to add pages and write posts
Static website in the front-end
Simple and reliable CI/CD
No/minimal maintenance after the first setup
Self-hostable (I was taking this for granted so much that I forgot to write it)
If it requires forge integration, it should support #ForgeJo
I am in urgent job search mode, so I'm gonna throw this out here and see if anything comes of it.
I am a #Canadian, fluent in both #English and #French. I have experience with several programming languages. My strongest proficiency is with #Haskell and #C. I also have a reasonable grasp of #HTML, #JavaScript, #SQL, #Python, #Lua, #Linux system administration, #bash scripting, #Perl, #AWK, some #Lisp (common, scheme, and emacs), and probably several others I've forgotten to mention.
I am not necessarily looking for something in tech. I just need something stable. I have done everything from software development, to customer support, to factory work, though my current circumstances make in-person work more difficult than remote work. I have been regarded as a hard worker in every job I have ever held.
I am in urgent job search mode, so I'm gonna throw this out here and see if anything comes of it.
I am a #Canadian, fluent in both #English and #French. I have experience with several programming languages. My strongest proficiency is with #Haskell and #C. I also have a reasonable grasp of #HTML, #JavaScript, #SQL, #Python, #Lua, #Linux system administration, #bash scripting, #Perl, #AWK, some #Lisp (common, scheme, and emacs), and probably several others I've forgotten to mention.
I am not necessarily looking for something in tech. I just need something stable. I have done everything from software development, to customer support, to factory work, though my current circumstances make in-person work more difficult than remote work. I have been regarded as a hard worker in every job I have ever held.
Nonfree #JavaScript may be taking away your freedom without your realizing it! Many web sites require proprietary JavaScript. Nonfree JavaScript subjugates users in the same way as any piece of proprietary software. Learn more: https://u.fsf.org/freejs
I am in urgent job search mode, so I'm gonna throw this out here and see if anything comes of it.
I am a #Canadian, fluent in both #English and #French. I have experience with several programming languages. My strongest proficiency is with #Haskell and #C. I also have a reasonable grasp of #HTML, #JavaScript, #SQL, #Python, #Lua, #Linux system administration, #bash scripting, #Perl, #AWK, some #Lisp (common, scheme, and emacs), and probably several others I've forgotten to mention.
I am not necessarily looking for something in tech. I just need something stable. I have done everything from software development, to customer support, to factory work, though my current circumstances make in-person work more difficult than remote work. I have been regarded as a hard worker in every job I have ever held.
Biome has released v2.0 beta with support for custom plugins, domain-specific linting, and multi-file analysis. The update brings type-aware rules to the Rust-powered #JavaScript toolchain. Next up: @biomejs plans to add HTML support and embedded languages in 2025. https://socket.dev/blog/biome-announces-v2-0-beta#TypeScript
Just made my day: "I somehow made it to March 2025 before being aware of https://thi.ng/ - an incredible mountain of code created primarily by a prolific genius, full of ideas that are like catnip to me."
(Also, to clarify, even though thi.ng/hiccup and a small selection of other thi.ng libs started out porting concepts widely used in Clojure (the language I spent 7 years with previously), in many cases the scope, features, usability & potential use cases have been far extended far beyond their "originals" and it sometimes saddens me that these are often just plainly ignored or mis-labeled/described...)
> HarmonyOS initially began as a project based on the Android Open Source Project and the Linux kernel, allowing compatibility with existing Android apps. In 2023, Huawei introduced HarmonyOS NEXT, a new iteration built on a custom microkernel and proprietary technology frameworks.
> Unlike its predecessor, HarmonyOS NEXT does not support Android or Windows applications. Instead, it uses a native application format based on JavaScript, TypeScript, and an optimized compiler designed to accelerate JavaScript execution. In 2024, Huawei confirmed its plans to replace Windows with HarmonyOS for its upcoming PC models.
> In addition to its HarmonyOS-based PC, Huawei is developing a Linux-based system, according to MyDrivers. The upcoming MateBook D16 Linux Edition will feature the same hardware as the standard MateBook D16, with an unnamed Linux distribution replacing Windows.
ALT text detailsScreenshot of 4'33" website, showing several boxes with audio players and their features. A play button and a time element are available on each player. The time starts at 00:00:00
ALT text detailsScreenshot of 4'33" website, showing several boxes with audio players and their features. A play button and a time element are available on each player. The time starts at 00:00:00
To avoid a massive OpenCV dependency for a current project I'm involved in, I ended up porting my own homemade, naive optical flow code from 2008 and just released it as a new package. Originally this was written for a gestural UI system for Nokia retail stores (prior to the Microsoft takeover), the package readme contains another short video showing the flow field being utilized to rotate a 3D cube:
ALT text details20 second screen recording of me waving my hand in camera and visualizing the resulting optical flow field (as blue arrows). The thick red line shows the field's average movement vector for the current frame.
- Built-in OpenTelemetry support for span context propagators (tracecontext, baggage) - Built-in OTel tracing for node:http.request - LSP now starts the TypeScript server lazily
- Built-in OpenTelemetry support for span context propagators (tracecontext, baggage) - Built-in OTel tracing for node:http.request - LSP now starts the TypeScript server lazily
- Built-in OpenTelemetry support for span context propagators (tracecontext, baggage) - Built-in OTel tracing for node:http.request - LSP now starts the TypeScript server lazily
- Built-in OpenTelemetry support for span context propagators (tracecontext, baggage) - Built-in OTel tracing for node:http.request - LSP now starts the TypeScript server lazily
- Built-in OpenTelemetry support for span context propagators (tracecontext, baggage) - Built-in OTel tracing for node:http.request - LSP now starts the TypeScript server lazily
- Built-in OpenTelemetry support for span context propagators (tracecontext, baggage) - Built-in OTel tracing for node:http.request - LSP now starts the TypeScript server lazily
- Built-in OpenTelemetry support for span context propagators (tracecontext, baggage) - Built-in OTel tracing for node:http.request - LSP now starts the TypeScript server lazily
- Built-in OpenTelemetry support for span context propagators (tracecontext, baggage) - Built-in OTel tracing for node:http.request - LSP now starts the TypeScript server lazily
Sometimes my follower count seemingly fluctuates at random. To understand why, I dug into the #MastodonAPI and created "fedi-followers":
A privacy-friendly #fediverse#followers explorer as local-only static web app, decentrally hosted on the #ipfs. See who's actually following (and unfollowing) you over time and much more.
Leaky buckets are commonly used in communication networks for rate limiting, traffic shaping and bandwidth control, but are equally useful in other domains requiring similar constraints.
A Leaky Bucket is a managed counter with an enforced maximum value (i.e. bucket capacity). The counter is incremented for each a new event to check if it can/should be processed. If the bucket capacity has already been reached, the bucket will report an overflow, which we can then handle accordingly (e.g. by dropping or queuing events). The bucket also has a configurable time interval at which the counter is decreasing (aka the "leaking" behavior) until it reaches zero again (i.e. until the bucket is empty). Altogether, this setup can be utilized to ensure both an average rate, whilst also supporting temporary bursting in a controlled fashion...
Related, I've also updated/simplified the rate limiter interceptor in https://thi.ng/server to utilize this new package...
just under TWO WEEKS until the submission deadline for Good Internet magazine: march 15, 2025!
☂️ Good Internet launches in May 2025. it's a volunteer-run, not-for-profit print and digital quarterly magazine for personal website owners and those interested in using the internet as a means of self-expression, art, and recreation.
🔎 we're looking for 1,500 to 4,000 word articles about anything for that audience!
* internet history * personal websites & blogs * #accessibility on the #indieweb * finding inspiration for a #blog * #webdesign trends (current or old) * running from the #enshittification of the web * lessons or post-mortems from web projects * news or overviews of #opensource projects * #privacy on the indieweb
🔍 also looking for any #art submissions centered around the web, coding, internet culture, and digital art!
if it relates to hobbies on "this side of the web," we probably want to run it!
✨ you can have your article submitted as text and images only OR you can code a whole webpage that helps tell your story!
🌊 if you're interested in learning more, sign up for our email list or check out the submission guidelines @ https://goodinternetmagazine.com!
🙏 (please boost if you can! <3 getting the word out helps so much!)
Ever wanted to add a new lint rule but gave up because fixing all existing files felt impossible? 🤔 Enter Lint to the Future—a way to progressively improve massive codebases *without* overwhelming PRs or ignored warnings.
just under TWO WEEKS until the submission deadline for Good Internet magazine: march 15, 2025!
☂️ Good Internet launches in May 2025. it's a volunteer-run, not-for-profit print and digital quarterly magazine for personal website owners and those interested in using the internet as a means of self-expression, art, and recreation.
🔎 we're looking for 1,500 to 4,000 word articles about anything for that audience!
* internet history * personal websites & blogs * #accessibility on the #indieweb * finding inspiration for a #blog * #webdesign trends (current or old) * running from the #enshittification of the web * lessons or post-mortems from web projects * news or overviews of #opensource projects * #privacy on the indieweb
🔍 also looking for any #art submissions centered around the web, coding, internet culture, and digital art!
if it relates to hobbies on "this side of the web," we probably want to run it!
✨ you can have your article submitted as text and images only OR you can code a whole webpage that helps tell your story!
🌊 if you're interested in learning more, sign up for our email list or check out the submission guidelines @ https://goodinternetmagazine.com!
🙏 (please boost if you can! <3 getting the word out helps so much!)
just under TWO WEEKS until the submission deadline for Good Internet magazine: march 15, 2025!
☂️ Good Internet launches in May 2025. it's a volunteer-run, not-for-profit print and digital quarterly magazine for personal website owners and those interested in using the internet as a means of self-expression, art, and recreation.
🔎 we're looking for 1,500 to 4,000 word articles about anything for that audience!
* internet history * personal websites & blogs * #accessibility on the #indieweb * finding inspiration for a #blog * #webdesign trends (current or old) * running from the #enshittification of the web * lessons or post-mortems from web projects * news or overviews of #opensource projects * #privacy on the indieweb
🔍 also looking for any #art submissions centered around the web, coding, internet culture, and digital art!
if it relates to hobbies on "this side of the web," we probably want to run it!
✨ you can have your article submitted as text and images only OR you can code a whole webpage that helps tell your story!
🌊 if you're interested in learning more, sign up for our email list or check out the submission guidelines @ https://goodinternetmagazine.com!
🙏 (please boost if you can! <3 getting the word out helps so much!)
🆕 blog! “Using the Web Crypto API to Generate TOTP Codes in JavaScript Without 3rd Party Libraries”
The Web Crypto API is, thankfully, nothing to do with scammy cryptocurrencies. Instead, it provides access to powerful cryptographic features which were previously only available in 3rd party tools.
🆕 blog! “Using the Web Crypto API to Generate TOTP Codes in JavaScript Without 3rd Party Libraries”
The Web Crypto API is, thankfully, nothing to do with scammy cryptocurrencies. Instead, it provides access to powerful cryptographic features which were previously only available in 3rd party tools.
🆕 blog! “Using the Web Crypto API to Generate TOTP Codes in JavaScript Without 3rd Party Libraries”
The Web Crypto API is, thankfully, nothing to do with scammy cryptocurrencies. Instead, it provides access to powerful cryptographic features which were previously only available in 3rd party tools.
Hey everyone, what's cooking in the open-source universe? 🤯 I just stumbled upon something that's seriously mind-blowing.
So, there's this Python library pretending to be a music tool (automslc), but get this – it's actually illegally downloading songs from Deezer! And the worst part? It turns your computer into an accomplice in a huge music piracy operation. Seriously, a digital pirate cove. 🏴☠️
And then there's this npm saga with @ton-wallet/create... Crypto wallet emptied, just like that! 💸
The moral of the story? Open source rocks, but blindly trusting everything is a recipe for disaster. Always double-check those dependencies! Automated scans are cool, but a real penetration test? That's pure gold. 🥇
Clients are always so appreciative when we can spot and fix this kind of stuff beforehand!
Now, I'm curious: What are your go-to methods for keeping your codebase squeaky clean and secure? Any tips or tricks you'd like to share?
Soy un Tech Lead y entusiasta de Angular, al igual que muchos de ustedes. La evolución del framework es constante y apasionante. Comparto un hilo sobre las últimas novedades y lo que se anticipa para las próximas versiones. 🚀 #Angular#Angular18#Angular19#Angular20#webdev#javascript#frontend
I always thought there is no way to track upload progress with fetch. Here my idea: I can pass a ReadableStream as body. Can I track upload progress through a proxy stream? At the moment I am using XMLHttpRequest just for tracking upload requests. But the XMLHttpRequest is annoying to handle and hard to read #WebDev#JavaScript
To learn more about how Kitten automatically implements authentication for your Small Web sites and apps using public-key cryptography (so even your own server doesn’t know your secret)¹, please see the Authentication tutorial:
¹ The security (and privacy) of Domain/Kitten are based on a 32-byte cryptographically random secret string that only the person who owns/controls a domain knows.
This is basically a Base256-encoded ed25519 secret key where the Base256 alphabet is a set of curated emoji surrogate pairs without any special modifiers chosen mainly from the animals, plants, and food groups with some exceptions (to avoid common phobias or triggers, etc.) that we call KittenMoji.
…
When setting up a Small Web app via Domain, this key is generated in the person’s browser, on their own computer, and is never communicated to either the Domain instance or the Kitten app being installed. Instead the ed25519 public key is sent to both and signed token authentication is used when the server needs to verify the owner’s identity (e.g., before allowing access to the administration area).
The expected/encouraged behaviour is for the person to store this secret in their password manager of choice.
To learn more about how Kitten automatically implements authentication for your Small Web sites and apps using public-key cryptography (so even your own server doesn’t know your secret)¹, please see the Authentication tutorial:
¹ The security (and privacy) of Domain/Kitten are based on a 32-byte cryptographically random secret string that only the person who owns/controls a domain knows.
This is basically a Base256-encoded ed25519 secret key where the Base256 alphabet is a set of curated emoji surrogate pairs without any special modifiers chosen mainly from the animals, plants, and food groups with some exceptions (to avoid common phobias or triggers, etc.) that we call KittenMoji.
…
When setting up a Small Web app via Domain, this key is generated in the person’s browser, on their own computer, and is never communicated to either the Domain instance or the Kitten app being installed. Instead the ed25519 public key is sent to both and signed token authentication is used when the server needs to verify the owner’s identity (e.g., before allowing access to the administration area).
The expected/encouraged behaviour is for the person to store this secret in their password manager of choice.
Missed the #LPI 25th anniversary giveaway? We’re extending the deadline!
To show our appreciation for the community that makes our efforts to support #FOSS possible: every 25th candidate who takes an #LPI exam Jan. 1 - March 31st will receive a free voucher for their next exam!
Missed the #LPI 25th anniversary giveaway? We’re extending the deadline!
To show our appreciation for the community that makes our efforts to support #FOSS possible: every 25th candidate who takes an #LPI exam Jan. 1 - March 31st will receive a free voucher for their next exam!
Going live in a few minutes! Join me as building tools for SOMOS.tech using JavaScript (yuck) and Azure!
Yesterday we got a chatbot working (yay me!) from scratch.
Today? No idea.
But we’re learning and cursing along the way.
Expect some frustration, and my first test of a custom multistreaming setup—fingers crossed it works! Come hang out, chat, and let’s figure this out together.
I'd like to *finish* this #JavaScript library and guarantee it will receive no further updates. To do that, I must first find and test every edge case. That seems like it might be possible because it's only 18 lines of code.
Very likely today I will start the gen-AI related project for SOMOS.tech. I'll be building from scratch using TypeScript/JavaScript. And when I say from scratch, I mean from ZERO—creating the repo and setting up my VSCode and extensions. Just a fair warning, I'm not a Javascript expert, so expect some learning pains, frustration, and maybe a few cursed words along the way. #GenAI#SOMOStech#TypeScript#JavaScript
Very likely today I will start the gen-AI related project for SOMOS.tech. I'll be building from scratch using TypeScript/JavaScript. And when I say from scratch, I mean from ZERO—creating the repo and setting up my VSCode and extensions. Just a fair warning, I'm not a Javascript expert, so expect some learning pains, frustration, and maybe a few cursed words along the way. #GenAI#SOMOStech#TypeScript#JavaScript
My book on 📘 LangGraph & AI Agents is almost ready to launch! Please help chose the book cover design. Just add in the comments your vote, or any suggestions. And btw, you can check the Table of Contents here: 👉 https://forms.gle/SZpqDgWWmzg3pYXWA
My book on 📘 LangGraph & AI Agents is almost ready to launch! Please help chose the book cover design. Just add in the comments your vote, or any suggestions. And btw, you can check the Table of Contents here: 👉 https://forms.gle/SZpqDgWWmzg3pYXWA
I'm going to build building an AI-powered app from scratch, focusing on javascript/typescript/azure and possibly dotnet for SOMOS.tech. I've got about a month to get it done, so it's going to be a wild ride!
I'm going to stream the process live and build in public.
However, due to my peculiar hours, the streaming might come with little to no notice.
I have seen careful and pedantic coders build impressive things with python and js while I tend to make a mess that's impossible to maintain. I also waste many hours debugging.
So for me, a strictly typed language leads to long term productivity. I also take on bigger problems with confidence.
Over the past few months, we've made several improvements to our documentation: 🗂️ better organized examples 📸 video tutorials 💻 more documentation in API reference and much more —
Are you still using npm transpile services like esm.sh and unpkg.com? ❌ dependency deduplication ❌ install hooks and native add-ons ❌ loading data files
Here's why we recommend importing npm packages natively via npm specifiers 👇
Haven't talked about LogTape in a while—it's a #logging library I made for #JavaScript and #TypeScript. You know how logging can be a pain point in JavaScript/TypeScript development? Well, I tried to address some common frustrations.
What makes it special
Zero dependencies
We've all been there with dependency hell, right? #LogTape has absolutely no external dependencies. Install it without worrying about bloating your node_modules.
You can organize your logs in a tree structure. Want to save only database-related logs to a file? Easy to do. Child categories can inherit settings from their parents too, which keeps things clean and manageable.
Writing a library and want to include logs without stepping on your users' toes? LogTape lets you add logging to your library while giving end users complete control over how those logs are handled.
Haven't talked about LogTape in a while—it's a #logging library I made for #JavaScript and #TypeScript. You know how logging can be a pain point in JavaScript/TypeScript development? Well, I tried to address some common frustrations.
What makes it special
Zero dependencies
We've all been there with dependency hell, right? #LogTape has absolutely no external dependencies. Install it without worrying about bloating your node_modules.
You can organize your logs in a tree structure. Want to save only database-related logs to a file? Easy to do. Child categories can inherit settings from their parents too, which keeps things clean and manageable.
Writing a library and want to include logs without stepping on your users' toes? LogTape lets you add logging to your library while giving end users complete control over how those logs are handled.
Haven't talked about LogTape in a while—it's a #logging library I made for #JavaScript and #TypeScript. You know how logging can be a pain point in JavaScript/TypeScript development? Well, I tried to address some common frustrations.
What makes it special
Zero dependencies
We've all been there with dependency hell, right? #LogTape has absolutely no external dependencies. Install it without worrying about bloating your node_modules.
You can organize your logs in a tree structure. Want to save only database-related logs to a file? Easy to do. Child categories can inherit settings from their parents too, which keeps things clean and manageable.
Writing a library and want to include logs without stepping on your users' toes? LogTape lets you add logging to your library while giving end users complete control over how those logs are handled.
Haven't talked about LogTape in a while—it's a #logging library I made for #JavaScript and #TypeScript. You know how logging can be a pain point in JavaScript/TypeScript development? Well, I tried to address some common frustrations.
What makes it special
Zero dependencies
We've all been there with dependency hell, right? #LogTape has absolutely no external dependencies. Install it without worrying about bloating your node_modules.
You can organize your logs in a tree structure. Want to save only database-related logs to a file? Easy to do. Child categories can inherit settings from their parents too, which keeps things clean and manageable.
Writing a library and want to include logs without stepping on your users' toes? LogTape lets you add logging to your library while giving end users complete control over how those logs are handled.
Haven't talked about LogTape in a while—it's a #logging library I made for #JavaScript and #TypeScript. You know how logging can be a pain point in JavaScript/TypeScript development? Well, I tried to address some common frustrations.
What makes it special
Zero dependencies
We've all been there with dependency hell, right? #LogTape has absolutely no external dependencies. Install it without worrying about bloating your node_modules.
You can organize your logs in a tree structure. Want to save only database-related logs to a file? Easy to do. Child categories can inherit settings from their parents too, which keeps things clean and manageable.
Writing a library and want to include logs without stepping on your users' toes? LogTape lets you add logging to your library while giving end users complete control over how those logs are handled.
🚀 Big news for Node.js developers! require(esm) has been backported to Node.js 20, removing a major roadblock for ESM adoption. With Node 18 nearing EOL, library maintainers can finally go ESM-only with confidence. 🎉
🚀 Big news for Node.js developers! require(esm) has been backported to Node.js 20, removing a major roadblock for ESM adoption. With Node 18 nearing EOL, library maintainers can finally go ESM-only with confidence. 🎉
🚀 Big news for Node.js developers! require(esm) has been backported to Node.js 20, removing a major roadblock for ESM adoption. With Node 18 nearing EOL, library maintainers can finally go ESM-only with confidence. 🎉
🚀 Big news for Node.js developers! require(esm) has been backported to Node.js 20, removing a major roadblock for ESM adoption. With Node 18 nearing EOL, library maintainers can finally go ESM-only with confidence. 🎉
Are you still using npm transpile services like esm.sh and unpkg.com? ❌ dependency deduplication ❌ install hooks and native add-ons ❌ loading data files
Here's why we recommend importing npm packages natively via npm specifiers 👇
Latest attempt at building better documentation for https://thi.ng/umbrella (also to make it available offline!): Having noticed that recent versions of TypeDoc support extracting & merging of doc strings from monorepos, over the past few weeks I've been updating/cleaning docstrings in hundreds of source files across all 200+ packages and started building a small tool to assemble a single/mega-page documentation (currently ~4.3MB of just HTML). The tool translates existing docstrings and references contained therein (and still used for the existing API docs) to support proper cross-package references.
Please be aware that so far this is only an early stage prototype and only contains very limited docs. I.e. there are no generics/typeparams, no details about classes/interfaces... But at least I know now HOW to add this all, as well as all the additional metadata I've already got (currently still only available via other custom tools/examples).
For example, there're links to the tag-based browser[1] and I'm also planning to add the fuzzy doc search engine/index[2] to this new documentation... The tag browser integration still needs more work in terms of correctly matching package names to tags. The underlying system is there already, just needs more work in terms of actually doing/assigning the concept mapping. Since most package names in thi.ng/umbrella are very plain/boring (for a reason), for many (most?) packages this already works pretty well:
ALT text detailsScreenshot of the documentation tool/page mentioned in the post, showing the API docs for this function (dark color scheme): https://docs.thi.ng/umbrella/#fuzzy-viz:instrumentStrategy
ALT text detailsScreenshot of the documentation tool/page mentioned in the post, showing the API docs for this function (light color scheme): https://docs.thi.ng/umbrella/#fuzzy-viz:instrumentStrategy
Donno about you guys but it sure is nice not to have to try and decipher the clusterfuck-like syntax of Hugo’s Go-based templating engine anymore…
The code on the left is Kitten¹, on the right is Hugo².
Kitten’s ‘template engine’ is just JavaScript tagged template strings.
(I’m porting the Small Technology Foundation web site³ from Site.js⁴ to Kitten, and in the process from being a Hugo-based static site to a dynamic one with a nice little admin panel I’m making to make it trivially easy to add new news items, events, and videos.)
Your web server having an interactive shell (REPL) where you can live update entries in your site/app’s database is pretty neat (if I do say so myself) :)
(I’m porting the Small Technology Foundation site¹ from Site.js² – and hence from being a static site generated via Site.js’s integrated Hugo³ – to Kitten⁴. In the process, I’m creating an admin panel⁵ for the news, events, and videos sections, which will make them easier to update, and storing the data in Kitten’s internal JavaScript Database⁶.)
Your web server having an interactive shell (REPL) where you can live update entries in your site/app’s database is pretty neat (if I do say so myself) :)
(I’m porting the Small Technology Foundation site¹ from Site.js² – and hence from being a static site generated via Site.js’s integrated Hugo³ – to Kitten⁴. In the process, I’m creating an admin panel⁵ for the news, events, and videos sections, which will make them easier to update, and storing the data in Kitten’s internal JavaScript Database⁶.)
• Kitten (rolling release) • @small-tech/https version 5.3.2 • Auto Encrypt version 4.1.3
OCSP support has been reinstated in the server so existing sites with Let’s Encrypt certificates provisioned prior to the removal of the OCSP stapling requirement will not fail to load in Firefox.
Kitten servers in production will automatically update to this version in a few hours. You can also sign in to the Kitten settings page on your server and do a manual update to update Kitten immediately.
Over the past few months, we've made several improvements to our documentation: 🗂️ better organized examples 📸 video tutorials 💻 more documentation in API reference and much more —
The latest development in @deno_land 's petition to cancel Oracle’s claim to the #JavaScript trademark: Oracle used Node.js as proof of use & is seeking to dismiss fraud claims, delaying the case and avoiding questions about its right to the name.
Over the past few months, we've made several improvements to our documentation: 🗂️ better organized examples 📸 video tutorials 💻 more documentation in API reference and much more —
The latest development in @deno_land 's petition to cancel Oracle’s claim to the #JavaScript trademark: Oracle used Node.js as proof of use & is seeking to dismiss fraud claims, delaying the case and avoiding questions about its right to the name.
The latest development in @deno_land 's petition to cancel Oracle’s claim to the #JavaScript trademark: Oracle used Node.js as proof of use & is seeking to dismiss fraud claims, delaying the case and avoiding questions about its right to the name.
I'm a #Programmer/#SoftwareEngineer. I'm most fluent in #Python, have some basics in #Java and #C++, but I'm also taking up new languages like #Javascript and others in my eternal journey of getting better and minimising the impostor syndrome that befalls pretty much all programmers (I feel). I'm also very experienced in #CloudNative/#DevOps technologies, and have been the one devising solutions and maintaining infrastructure in a fast-paced startup environment in my previous employment.
I'm passionate in what I do and those that know me here or IRL would know that I'm always yapping about the things I'm learning or working on - I love discussing them, and I love helping people out - esp those on the same boat as me.
This passion has led me into writing and maintaining tons of #FOSS projects like Mango: a content distribution framework based on #Django for #Mastodon and #Bluesky that powers various bots of mine like @lowyat@mastodon.social and @waktusolat@mastodon.social, Charts: a #Helm chart repository for an easy and reproducible deployment strategy for all my projects and everything else I self-host on my #homelab, and Orked: O-tomated #RKE2 distribution, a collection of scripts I wrote that are comprehensively documented to enable everyone to self-host a production-grade #Kubernetes cluster for absolutely free in their homes.
I'm based in Malaysia, but I'm open to just about any on-site, hybrid, or remote job opportunities anywhere. In the meantime though, I'm actively looking for a job in countries like #Japan and #Singapore, in a bid for a desperate lifestyle change. I've linked below my Portfolio (which you too, could self-host your own!), for those who'd wish to connect/learn more of me. Thank you ❤️
I'm a #Programmer/#SoftwareEngineer. I'm most fluent in #Python, have some basics in #Java and #C++, but I'm also taking up new languages like #Javascript and others in my eternal journey of getting better and minimising the impostor syndrome that befalls pretty much all programmers (I feel). I'm also very experienced in #CloudNative/#DevOps technologies, and have been the one devising solutions and maintaining infrastructure in a fast-paced startup environment in my previous employment.
I'm passionate in what I do and those that know me here or IRL would know that I'm always yapping about the things I'm learning or working on - I love discussing them, and I love helping people out - esp those on the same boat as me.
This passion has led me into writing and maintaining tons of #FOSS projects like Mango: a content distribution framework based on #Django for #Mastodon and #Bluesky that powers various bots of mine like @lowyat@mastodon.social and @waktusolat@mastodon.social, Charts: a #Helm chart repository for an easy and reproducible deployment strategy for all my projects and everything else I self-host on my #homelab, and Orked: O-tomated #RKE2 distribution, a collection of scripts I wrote that are comprehensively documented to enable everyone to self-host a production-grade #Kubernetes cluster for absolutely free in their homes.
I'm based in Malaysia, but I'm open to just about any on-site, hybrid, or remote job opportunities anywhere. In the meantime though, I'm actively looking for a job in countries like #Japan and #Singapore, in a bid for a desperate lifestyle change. I've linked below my Portfolio (which you too, could self-host your own!), for those who'd wish to connect/learn more of me. Thank you ❤️
I've worked with dates and times in several programming languages, and I have to say that the best is easily PHP (since the big refactor in, what was it, 5.6?).
I've worked with dates and times in several programming languages, and I have to say that the best is easily PHP (since the big refactor in, what was it, 5.6?).
#Introduction Greetings! I'm a #software developer in the world of #dotnet and #JavaScript. Worth mentioning - a degree in game dev and table tennis coaching credentials.
I won a Hackathon, and once increased sales by 300%. In my timeline, you'll mostly find reflections on programming, as it is my bread and butter, as my odyssey into open-source continues.
Here to exchange ideas, learn, and share wisdom. Open for spirited discussions. Always game for a chat, so feel free to reach out.
tl;dr I created an extension for the GNOME desktop on Linux, so that folks can stream and listen to music from The Indie Beat – an online radio station powered by independent musicians sharing music in the Fediverse, via Bandwagon.
Background
Independent musicians, creatives, artists, makers – these are all folk who often struggle to connect with audiences, and where retail and tech platforms tend towards squeezing their ability to make money from their work (see the excellent Chokepoint Capitalism by Cory Doctorow – essential reading for today’s world and understanding how it systematically squeezes creatives). Over the Christmas period, I finally deleted my Spotify account, after reading about yet more awful ways that company is destroying authentic creativity for their own profit.
I’ve been a huge fan of independent artists for a very long time. Back in the MySpace / MP3 / Napster days I came across folks who I now count as friends, amazing musicians such as Cindy Alexander, and Alex Cornish.
Up until recently there was a wonderful streaming station, RadioFreeFedi, that offered music from artists who had a presence in the Fediverse. Sadly, that has now gone away.
Over the past couple of years I’ve been attending Fediforum, an online conference where people building in the Fediverse gather to share projects and ideas. During the events in 2024, I came across two fantastic people with an interest in making things better for artists and musicians: Ben Pate, builder of the Emissary platform, which has a music-centric edition called Bandwagon; and Kirsten Lambertsen, a multi-talented web creative who runs Patron Hunt, and who spun up an alternative streaming station, The Indie Beat.
Happy New Year fedifriends!
I'm excited to officially announce the launch of TheIndieBeat.fm, a streaming radio station showcasing indie #music from the Fediverse.
The Indie Beat Radio is made possible through a collaboration with Bandwagon.fm / @benpate
Music artists who upload their work to Bandwagon.fm have the option to make tracks available for streaming on TheIndieBeat.fm
Our goal is to use federation to make less work for artists — upload once; distribute infinitely.
The Indie Beat builds on Bandwagon, so artists who share their music in the Fediverse via Bandwagon, can also choose to add them to rotation on The Indie Beat.
Some inspirations
I was nerd-sniped, I mean, inspired, to make something with The Indie Beat, in part through a nice blog post shared by Neil Brown (which was apparently prompted by me, so that’s nice and circular!) about how to add the streams from The Indie Beat into Linux music apps such as mpd.
I don’t use mpd, and to be honest I most often live on Apple platforms (but I do keep a Plex server, which I intend to move to Jellyfin this year as I work on improving my self-hosting and homelab situations). I was pretty sure that I’d seen a taskbar music player for GNOME, though. I usually run GNOME on my Linux systems – the exception being my MNT Pocket Reform, which is Sway with a minimal set of other desktop apps.
The player I was thinking of is the SomaFM internet radio extension, which is a menubar app that lists the SomaFM station streams, and allows the user to choose between them.
The process
The first iteration was a straightforward copy/edit hack of the SomaFM extension, replacing the list of channel streams with the equivalent ones from The Indie Beat. Easy!
I excitedly sent a screenshot to Kirsten to show off!
There were quite a few things that I felt I could do better, though. First of all, the artwork was missing. Also, I knew that the whole point of The Indie Beat was to be a showcase for the artists on Bandwagon, and that there was supposed to be metadata in the stream header that contained their link information.
After a lot of poking at the MP3 stream, I realised that The Indie Beat is built on a streaming server called Azura Cast, which has an API – and The Indie Beat API had that data, and a whole lot more that I could use. In order to use it all though, I had to fully re-think how the extension would work.
So, I started over, from scratch.
I hand-traced the “catellite” artwork and made a minified icon for the GNOME top bar – the full design was not great at a tiny size.
I kept a similar look-and-feel to the SomaFM extension – an icon, a player, a list of channels – but, I removed the settings and favourites options from my scope, to keep things simple. I also have the menu expand to fit the channel names, which I don’t love as it means it changes size, but it works.
a little thing that I’m fond of is that the extension uses the configured accent colour – recently added in GNOME 47 – for some of the text.
I did a lot of reading and poking around at GNOME Shell and gjs, the JavaScript API that enables extensions to be built. I also learned a lot about GStreamer, the engine that GNOME apps use for access to audio and video media. This was all a long, long way from my past work coding for GNOME, ~20 years ago, back in early Anjuta days! I’m not naturally a JavaScript person at all, so I made a lot of mistakes here.
huge shout-out to the author of the JustPerfection extension, who carefully and helpfully reviewed my submissions to the GNOME Extensions site. This thing would be a lot more crashy and messy without that oversight!
the extension contains a small cached implementation of the Azura Cast API, which enables the extension to query the available channels, rather than needing to have a static internal list of streams updated if a channel came along or went away (a concept of “mixtapes” is on the roadmap for The Indie Beat in the future).
I needed to add a way to access an artist’s page, which comes from a property that’s stored in the now playing data, so building an API layer that sits parallel to the radio stream player seemed to work nicely.
The Indie Beat is evolving – within a few days of starting work on this side project, Kirsten switched the branding from pink to green, so I updated the artwork. She also added a Bonk Wave channel – and the extension seamlessly picked it up! That was a nice win.
Not What I Call Radio Bonk Wave is a new radio station from The Indie Beat Radio, curated by bonkwave.org and playing music which may be #BonkWave. Or may be #NotBonkWave.
I’ve posted a short video which covers the basic features: choose between channels, play/stop, open the Bandwagon page of the currently playing artist in a web browser, or directly jump to Bandwagon’s Explore page or The Indie Beat main page. I’ve aimed for simple and clean, as befits the GNOME philosophy.
There’s a lot of opportunity for creatives in the Fediverse!
Castopod is a great way to self-host a podcast with native ActivityPub federation. Bandwagon exists, where you can create a Fediverse profile for yourself and your music. You can share it through The Indie Beat. I’ve personally got my eye on Libre.FM (like Last.FM, but free, and with a renewed / reinvigorated interest in building new features like ActivityPub and IndieWeb support – here’s my profile). Beyond those, there is also Faircamp, a static site generator that helps musicians self-host their content and avoid enshittification through other channels and platforms. I’m excited! We can work together to make our spaces better for musicians and other artists!
More features for the extension?
This has been a fun side project!
I’ve got a few barely-formed ideas for things I can do with this in the future, as both Bandwagon and The Indie Beat evolve. Stay tuned. 📡
Oh, and through making this extension, I found and purchased an album I’m obsessed with, which has inspired me to do some other new things… so watch this space.
Update 26/02 – since posting this, folks have made me aware of some other fantastic options in this space. Hopefully, we can see more collaborations between these platforms / sites / curators, to grow the opportunity for everyone.
NHAM shares monthly online mixtapes of music from Fediverse musicians
Audio Interface, a set of radio shows for independent artists
the Faircamp Webring collects together many of the artists using Faircamp for their sites
Mirlo (there’s an open issue proposing that they add ActivityPub / Fediverse support)
Update 26/02 – I wanted a simple app to play The Indie Beat on my MNT Pocket Reform, too, so I made a more basic system tray app, that should work on most Linux desktops (written in Python)
Where do I get those stickers?
Come find me at FOSDEM 2025 in Brussels next weekend, I’ll have Bandwagon+The Indie Beat stickers to share 👍🏻
Today I dipped my toe into static site generation with @eleventy and it was a breeze! I didn’t know this #WebDevelopment stuff could actually be fun. I will now happily trade the complexities of #Wordpress plus visual site builders plus theme customization against the complexities of #SSG with vanilla #HTML / #CSS and (almost) no #JavaScript. If think, I‘ll redo all my sites with it. Hint: ChatGPT is also really good at teaching #Eleventy and CSS.
I've been hand rolling touch friendly elements in Svelte 5 + HTML + CSS. But it's getting a bit tedious, and I should probably try some UI component framework or library.
Trouble is, it's hard to choose, I have zero experience about any of them, not all of them are Svelte 5 compatible. What to do?
It's fine to do lots of up front work and learning provided I make the right choice. But boy it would suck to have to revert and start over with another library.
Twice a year, due to a very old system, many assumptions, user expectations, and a bright mind that decided to set a database in Europe/Amsterdam TZ, we have to deal with at least a bug regarding time issues. I cannot wait for Temporal to be fully implemented in all the platforms.
Replacing Date object. Adds support for time zone and calendar representations, many built-in methods for conversions, comparisons and computations, formatting, etc.
Replacing Date object. Adds support for time zone and calendar representations, many built-in methods for conversions, comparisons and computations, formatting, etc.
Fedify is an #ActivityPub server framework in #TypeScript & #JavaScript. It aims to eliminate the complexity and redundant boilerplate code when building a federated server app, so that you can focus on your business logic and user experience.
The key features it provides currently are:
Type-safe objects for Activity Vocabulary (including some vendor-specific extensions)
Fedify is an #ActivityPub server framework in #TypeScript & #JavaScript. It aims to eliminate the complexity and redundant boilerplate code when building a federated server app, so that you can focus on your business logic and user experience.
The key features it provides currently are:
Type-safe objects for Activity Vocabulary (including some vendor-specific extensions)
Our core team is looking for a senior Front-end Developer to elevate the web UI/UX experience for our users.
Ideally:
1. You are highly skilled in accessible and semantic #HTML 2. Proficient in modern #CSS 3. Experienced with #Javascript, #Typescript and complex React/Redux applications
This remote full-time position requires a 4-hour overlap with the CET timezone.
• npm install: 📦 Installs dependencies from package.json, updates package-lock.json if needed. Flexible but slower. • npm ci: ⚡ Clean, fast install based only on package-lock.json. Reproducible builds, perfect for CI/CD.
💡Tip: Use npm ci for consistent, reliable deployments! ✅ #javascript#npm
• npm install: 📦 Installs dependencies from package.json, updates package-lock.json if needed. Flexible but slower. • npm ci: ⚡ Clean, fast install based only on package-lock.json. Reproducible builds, perfect for CI/CD.
💡Tip: Use npm ci for consistent, reliable deployments! ✅ #javascript#npm
Edit : I found my internship, thank you everyone for reposting :)
Just migrated from my mastodon.social account to the post.lurk.org instance (thank you @rra for the invite and the ressources ) So... here is my little #Introduction post (also a post of me searching for an internship lol) : Hi, I'm Zineb, I am a moroccan girly pop who loves to code, to draw and to sing :3 Currently in the first year of my Master's degree in Communication at the Ésac art school in Cambrai (france), I'm searching for an #internship in the field of #graphicdesign, especially with collectives enthusiastic about #webtoprint and #opensource tools (like me!). I mainly code with #HTML and #CSS, and I am currently learning #javascript. I can speak fluently french, english and arabic. I also have some basic knowledge in spanish. In terms of location, I'm seeking an internship in #Belgium, the #Netherlands, #Germany or the region of Paris. (Oh, forgot to mention that I can have an erasmus/internship grant ) Here's the link to my website: https://zinebammar.neocities.org/
Edit : I found my internship, thank you everyone for reposting :)
Just migrated from my mastodon.social account to the post.lurk.org instance (thank you @rra for the invite and the ressources ) So... here is my little #Introduction post (also a post of me searching for an internship lol) : Hi, I'm Zineb, I am a moroccan girly pop who loves to code, to draw and to sing :3 Currently in the first year of my Master's degree in Communication at the Ésac art school in Cambrai (france), I'm searching for an #internship in the field of #graphicdesign, especially with collectives enthusiastic about #webtoprint and #opensource tools (like me!). I mainly code with #HTML and #CSS, and I am currently learning #javascript. I can speak fluently french, english and arabic. I also have some basic knowledge in spanish. In terms of location, I'm seeking an internship in #Belgium, the #Netherlands, #Germany or the region of Paris. (Oh, forgot to mention that I can have an erasmus/internship grant ) Here's the link to my website: https://zinebammar.neocities.org/
tl;dr I created an extension for the GNOME desktop on Linux, so that folks can stream and listen to music from The Indie Beat – an online radio station powered by independent musicians sharing music in the Fediverse, via Bandwagon.
Background
Independent musicians, creatives, artists, makers – these are all folk who often struggle to connect with audiences, and where retail and tech platforms tend towards squeezing their ability to make money from their work (see the excellent Chokepoint Capitalism by Cory Doctorow – essential reading for today’s world and understanding how it systematically squeezes creatives). Over the Christmas period, I finally deleted my Spotify account, after reading about yet more awful ways that company is destroying authentic creativity for their own profit.
I’ve been a huge fan of independent artists for a very long time. Back in the MySpace / MP3 / Napster days I came across folks who I now count as friends, amazing musicians such as Cindy Alexander, and Alex Cornish.
Up until recently there was a wonderful streaming station, RadioFreeFedi, that offered music from artists who had a presence in the Fediverse. Sadly, that has now gone away.
Over the past couple of years I’ve been attending Fediforum, an online conference where people building in the Fediverse gather to share projects and ideas. During the events in 2024, I came across two fantastic people with an interest in making things better for artists and musicians: Ben Pate, builder of the Emissary platform, which has a music-centric edition called Bandwagon; and Kirsten Lambertsen, a multi-talented web creative who runs Patron Hunt, and who spun up an alternative streaming station, The Indie Beat.
Happy New Year fedifriends!
I'm excited to officially announce the launch of TheIndieBeat.fm, a streaming radio station showcasing indie #music from the Fediverse.
The Indie Beat Radio is made possible through a collaboration with Bandwagon.fm / @benpate
Music artists who upload their work to Bandwagon.fm have the option to make tracks available for streaming on TheIndieBeat.fm
Our goal is to use federation to make less work for artists — upload once; distribute infinitely.
The Indie Beat builds on Bandwagon, so artists who share their music in the Fediverse via Bandwagon, can also choose to add them to rotation on The Indie Beat.
Some inspirations
I was nerd-sniped, I mean, inspired, to make something with The Indie Beat, in part through a nice blog post shared by Neil Brown (which was apparently prompted by me, so that’s nice and circular!) about how to add the streams from The Indie Beat into Linux music apps such as mpd.
I don’t use mpd, and to be honest I most often live on Apple platforms (but I do keep a Plex server, which I intend to move to Jellyfin this year as I work on improving my self-hosting and homelab situations). I was pretty sure that I’d seen a taskbar music player for GNOME, though. I usually run GNOME on my Linux systems – the exception being my MNT Pocket Reform, which is Sway with a minimal set of other desktop apps.
The player I was thinking of is the SomaFM internet radio extension, which is a menubar app that lists the SomaFM station streams, and allows the user to choose between them.
The process
The first iteration was a straightforward copy/edit hack of the SomaFM extension, replacing the list of channel streams with the equivalent ones from The Indie Beat. Easy!
I excitedly sent a screenshot to Kirsten to show off!
There were quite a few things that I felt I could do better, though. First of all, the artwork was missing. Also, I knew that the whole point of The Indie Beat was to be a showcase for the artists on Bandwagon, and that there was supposed to be metadata in the stream header that contained their link information.
After a lot of poking at the MP3 stream, I realised that The Indie Beat is built on a streaming server called Azura Cast, which has an API – and The Indie Beat API had that data, and a whole lot more that I could use. In order to use it all though, I had to fully re-think how the extension would work.
So, I started over, from scratch.
I hand-traced the “catellite” artwork and made a minified icon for the GNOME top bar – the full design was not great at a tiny size.
I kept a similar look-and-feel to the SomaFM extension – an icon, a player, a list of channels – but, I removed the settings and favourites options from my scope, to keep things simple. I also have the menu expand to fit the channel names, which I don’t love as it means it changes size, but it works.
a little thing that I’m fond of is that the extension uses the configured accent colour – recently added in GNOME 47 – for some of the text.
I did a lot of reading and poking around at GNOME Shell and gjs, the JavaScript API that enables extensions to be built. I also learned a lot about GStreamer, the engine that GNOME apps use for access to audio and video media. This was all a long, long way from my past work coding for GNOME, ~20 years ago, back in early Anjuta days! I’m not naturally a JavaScript person at all, so I made a lot of mistakes here.
huge shout-out to the author of the JustPerfection extension, who carefully and helpfully reviewed my submissions to the GNOME Extensions site. This thing would be a lot more crashy and messy without that oversight!
the extension contains a small cached implementation of the Azura Cast API, which enables the extension to query the available channels, rather than needing to have a static internal list of streams updated if a channel came along or went away (a concept of “mixtapes” is on the roadmap for The Indie Beat in the future).
I needed to add a way to access an artist’s page, which comes from a property that’s stored in the now playing data, so building an API layer that sits parallel to the radio stream player seemed to work nicely.
The Indie Beat is evolving – within a few days of starting work on this side project, Kirsten switched the branding from pink to green, so I updated the artwork. She also added a Bonk Wave channel – and the extension seamlessly picked it up! That was a nice win.
Not What I Call Radio Bonk Wave is a new radio station from The Indie Beat Radio, curated by bonkwave.org and playing music which may be #BonkWave. Or may be #NotBonkWave.
I’ve posted a short video which covers the basic features: choose between channels, play/stop, open the Bandwagon page of the currently playing artist in a web browser, or directly jump to Bandwagon’s Explore page or The Indie Beat main page. I’ve aimed for simple and clean, as befits the GNOME philosophy.
There’s a lot of opportunity for creatives in the Fediverse!
Castopod is a great way to self-host a podcast with native ActivityPub federation. Bandwagon exists, where you can create a Fediverse profile for yourself and your music. You can share it through The Indie Beat. I’ve personally got my eye on Libre.FM (like Last.FM, but free, and with a renewed / reinvigorated interest in building new features like ActivityPub and IndieWeb support – here’s my profile). Beyond those, there is also Faircamp, a static site generator that helps musicians self-host their content and avoid enshittification through other channels and platforms. I’m excited! We can work together to make our spaces better for musicians and other artists!
More features for the extension?
This has been a fun side project!
I’ve got a few barely-formed ideas for things I can do with this in the future, as both Bandwagon and The Indie Beat evolve. Stay tuned. 📡
Oh, and through making this extension, I found and purchased an album I’m obsessed with, which has inspired me to do some other new things… so watch this space.
Update 26/02 – since posting this, folks have made me aware of some other fantastic options in this space. Hopefully, we can see more collaborations between these platforms / sites / curators, to grow the opportunity for everyone.
NHAM shares monthly online mixtapes of music from Fediverse musicians
Audio Interface, a set of radio shows for independent artists
the Faircamp Webring collects together many of the artists using Faircamp for their sites
Mirlo (there’s an open issue proposing that they add ActivityPub / Fediverse support)
Update 26/02 – I wanted a simple app to play The Indie Beat on my MNT Pocket Reform, too, so I made a more basic system tray app, that should work on most Linux desktops (written in Python)
Where do I get those stickers?
Come find me at FOSDEM 2025 in Brussels next weekend, I’ll have Bandwagon+The Indie Beat stickers to share 👍🏻
ALT text detailsScreenshot of Kitten error page with cute illustration of a grey kitten with pink ears and nose playing with a purple ball of yarn followed by the error message:
500
Error: Attempt to instantiate kitten.Component in markup without calling its connectedTo() static factory method:
In your kitten.html``, replace:
<{Uptime} />
With:
<{Uptime.connectedTo(this)} />
Finally, there’s a partial view of a stack trace that scrolls off the page.
So last night, while recording the preview of Kitten’s¹ improved component model², I made a silly mistake (copying raw HTML into a JavaScript function instead of wrapping it in a kitten.html`` tagged template, easy to do when you’re refactoring to pull out components from pages).
Then, once I figured out what I’d done, I made another one by forgetting to return the value from the function (easy to do when you’re used to using one-line closures as render functions).
I would have caught both of those so much faster if Kitten had helpful error messages for those two pitfalls. And guess what, this morning, it does :)
Attached are screenshot showing the before and after error messages.
ALT text detailsScreenshot of first error message (before):
500 TypeError: Cannot read properties of undefined (reading 'match')
ALT text detailsScreenshot of first error message (after):
Error: Render function did not return kitten.html``
class Count extends kitten.Component {
html {
kitten.html`<h1 morph>${kitten.db.counter.count}</h1>`
}
onIncrement {
kitten.db.counter.count++
this.update
}
}
ALT text detailsScreenshot of second error message (before):
500 SyntaxError: Unexpected token '<
ALT text detailsScreenshot of second error message (after):
500 SyntaxError: Unexpected token '<
(Did you put raw HTML inside a function by mistake instead of wrapping it in a kitten.html`` tagged template?)
#introduction Code Lutin est une #entreprise extraordinaire : pratiquant l'#autogestion (1 personne = 1 voix) et le salaire unique (quelque-soit le diplôme, l'expérience, l'ancienneté, le poste), nous sommes une des rares société « à participation ouvrière » en France
#introduction Code Lutin est une #entreprise extraordinaire : pratiquant l'#autogestion (1 personne = 1 voix) et le salaire unique (quelque-soit le diplôme, l'expérience, l'ancienneté, le poste), nous sommes une des rares société « à participation ouvrière » en France
Little preview video: Kitten’s improved component model
• Class-based page routes and components • Object-oriented • Event-based • Seamless hypermedia-driven WebSocket-based event mapping and interface updates (Streaming HTML) • A light server-side live component hierarchy with event bubbling • Almost as if you’re building a desktop or mobile app instead of a web app…
… another authoring simplification made possible because on the Small Web – which is a peer-to-peer web – you build a web app/site as a tool for one person (the owner of the site/app) instead of as a tool for you to farm millions of people.
Je suis développeur, principalement #Python, #JavaScript et parfois C et ASM (surtout sur #GameBoy). Je suis aussi adminsys #Linux.
Je dev pas mal de logiciels libres et #OpenSource. Ça va de l'outil de configuration de souris gaming au générateur de playlist en passant par de l'optimisation d'images ou du shell PHP *hum*…
J'ai également un blog sur lequel je poste surtout du contenu technique mais j'aimerais bien diversifier un peu les sujets à l'avenir.
- Correct handling of compilerOptions.types - Better handling of npm package types - Improvements to node:fs FileHandle - Make deno outdated more robust Run `deno upgrade` to get it
- Correct handling of compilerOptions.types - Better handling of npm package types - Improvements to node:fs FileHandle - Make deno outdated more robust Run `deno upgrade` to get it
- Correct handling of compilerOptions.types - Better handling of npm package types - Improvements to node:fs FileHandle - Make deno outdated more robust Run `deno upgrade` to get it
- Correct handling of compilerOptions.types - Better handling of npm package types - Improvements to node:fs FileHandle - Make deno outdated more robust Run `deno upgrade` to get it
Pretty soon, you’re going to be able to view your live pages and the events on them in real time while developing Kitten apps.
The improved component model with support for class-based routes (and a server-side component hiearchy that lets you build well-encapsulated components and pages and work in an event-driven way) is coming along nicely and I’m back to writing Place¹ using it.
(In the GIF, you’re looking at Place’s profile settings page. Not shown here but those profile changes reflect in realtime on all open pages. The highlighted piece of code is what streams the event details to the browser.)
ALT text detailsScreen recording of two web browser windows, side by side. The one on the right is showing Kitten’s Settings page at state: pages. I open the detail veiw for the /settings/profile route and see its ID, session id, number of connected sockets (1) and an empty Events table with name and data.
On the left, an instance of the /settings/profile route is open in the browser. I change the value of the Name field (erasing the t and s from Aral’s 1st) and I see two events pop up on the page on the right (Name: name, Data: { name: 'Aral’s 1s'}) and (Name: name, Data: { name: 'Aral’s 1'}). Then I add the deleted letters back and see the event (Name: name, Data: { name: 'Aral’s 1st'}). Finally, I toggle the Show name? and Show Image? checkboxes on and off and see the events (name: howOrHide, { showOrHide: 'on', item: 'Image' }), (name: showOrHide, { item: 'Image' }, showOrHide { showOrHide: 'on', item: 'Name' })
ALT text detailsScreenshot of code. The showPageEvent method is highlighted.
onAddToPage () {
this.addEventHandler(kitten.events, `kittenPageEvent-${this._page.id}`, this.showPageEvent)
}
/**
Stream new page event details to top of the events list,
hiding the placeholder if necessary.
@param {{
name: string,
data: {HEADERS: any}
}} event
*/
showPageEvent (event) {
delete event.data.HEADERS
// Hide placeholder if necessary.
if (this.placeHolderIsVisible) {
this.page.send(kitten.html`
<tr id='placeholder-${this.id}' swap-target='delete'>
`)
this.placeHolderIsVisible = false
}
// Send the new event row with event details.
this.page.send(kitten.html`
<tbody id=${this.id} swap-target='afterend:#${this.id}'>
<tr>
<td>${event.name}</td>
<td>${util.inspect(event.data)}</td>
</tr>
</tbody>
`)
}
}
class Pages extends kitten.Component {
html() {
// We could just display a “loading” message here
// as we’re going to refresh the list at onConnect(),
// but given how fast it all happens, we might was well
// send the whole list instead of having an odd flash.
const pages = Object.values(kitten.pages)
Thanks to all who have participated. If we haven't contacted you about stickers, then please let us know (or email andy@deno.com).
Finally, one lucky winner will get the elite, special edition, hyper exclusive Deno sticker. (Here's Phil seeing it for the first time.) ️ More details 👇️ https://deno.com/blog/advent-of-code-2024
Thanks to all who have participated. If we haven't contacted you about stickers, then please let us know (or email andy@deno.com).
Finally, one lucky winner will get the elite, special edition, hyper exclusive Deno sticker. (Here's Phil seeing it for the first time.) ️ More details 👇️ https://deno.com/blog/advent-of-code-2024
Thanks to all who have participated. If we haven't contacted you about stickers, then please let us know (or email andy@deno.com).
Finally, one lucky winner will get the elite, special edition, hyper exclusive Deno sticker. (Here's Phil seeing it for the first time.) ️ More details 👇️ https://deno.com/blog/advent-of-code-2024
Good Morning #FediHire friends - have a new role for ya!
Looking for a fairly senior frontend-focused #Software Engineer to join a team building a containerization product for the CI/CD pipeline called Dagger.
The role is looking for some fairly specific criteria so here are the key points:
* This role is not a UI Designer position, you must have a strong coding background ( #JavaScript / #TypeScript / #ReactJS preferred) in addition to design chops
* You must have developed frontends for #devtools (the thought behind this requirement is that these tools are designed very differently than a typical B2C site so if you have done something substantially similar, answer yes)
* Americas (somewhere between EST to PST) timezones are required. We can hire in Canada, US, South America, and have hired in Europe before for exceptional candidates
* We cannot sponsor visas at this time
* I've worked with this company for about 6 months and have only positive things to say about the team and culture
* There's currently a bug in the application coming from the ATS that's making the dropdowns funky. Don't judge me too harshly, I've submitted a ticket
I'm the #recruiter on the role, so feel free to ask any questions here and I'll either have an answer or go find you one :)
Good Morning #FediHire friends - have a new role for ya!
Looking for a fairly senior frontend-focused #Software Engineer to join a team building a containerization product for the CI/CD pipeline called Dagger.
The role is looking for some fairly specific criteria so here are the key points:
* This role is not a UI Designer position, you must have a strong coding background ( #JavaScript / #TypeScript / #ReactJS preferred) in addition to design chops
* You must have developed frontends for #devtools (the thought behind this requirement is that these tools are designed very differently than a typical B2C site so if you have done something substantially similar, answer yes)
* Americas (somewhere between EST to PST) timezones are required. We can hire in Canada, US, South America, and have hired in Europe before for exceptional candidates
* We cannot sponsor visas at this time
* I've worked with this company for about 6 months and have only positive things to say about the team and culture
* There's currently a bug in the application coming from the ATS that's making the dropdowns funky. Don't judge me too harshly, I've submitted a ticket
I'm the #recruiter on the role, so feel free to ask any questions here and I'll either have an answer or go find you one :)
Deno is committed to web standards - that's why we co-founded WinterCG two years ago. Today marks the next step in that journey: WinterCG moves to Ecma International as technical comittee 55 (TC55).
Deno is committed to web standards - that's why we co-founded WinterCG two years ago. Today marks the next step in that journey: WinterCG moves to Ecma International as technical comittee 55 (TC55).
Deno is committed to web standards - that's why we co-founded WinterCG two years ago. Today marks the next step in that journey: WinterCG moves to Ecma International as technical comittee 55 (TC55).
Deno is committed to web standards - that's why we co-founded WinterCG two years ago. Today marks the next step in that journey: WinterCG moves to Ecma International as technical comittee 55 (TC55).
New release of https://thi.ng/genart-api (v0.24.0) — a platform-independent extensible API for browser-based computational/algorithmic/generative art projects:
This release contains quite a few new features, as well as several important fixes for bugs which were accidentally introduced in the two most recent versions...
- extracted the debug time provider & FPS overlay to separate package - updated `bigint` param handling (esp. randomization) - added `collector` and `iteration` metadata accessors - updated platform adapters (esp. the #fxhash one) - fixed image & ramp param handling - added a bunch of utilities to core API to deduplicate code in various adapters - updated/fixed examples & docs - added more tests (and updated core API to be more testable outside the browser)
Our core team is looking for a senior Front-end Developer to elevate the web UI/UX experience for our users.
Ideally:
1. You are highly skilled in accessible and semantic #HTML 2. Proficient in modern #CSS 3. Experienced with #Javascript, #Typescript and complex React/Redux applications
This remote full-time position requires a 4-hour overlap with the CET timezone.
Our core team is looking for a senior Front-end Developer to elevate the web UI/UX experience for our users.
Ideally:
1. You are highly skilled in accessible and semantic #HTML 2. Proficient in modern #CSS 3. Experienced with #Javascript, #Typescript and complex React/Redux applications
This remote full-time position requires a 4-hour overlap with the CET timezone.
Interesting change: “Lifecycle scripts of dependencies are not executed during installation by default! This is a breaking change aimed at increasing security. In order to allow lifecycle scripts of specific dependencies, they should be listed in the pnpm.onlyBuiltDependencies field of package.json.”
Interesting change: “Lifecycle scripts of dependencies are not executed during installation by default! This is a breaking change aimed at increasing security. In order to allow lifecycle scripts of specific dependencies, they should be listed in the pnpm.onlyBuiltDependencies field of package.json.”
Our core team is looking for a senior Front-end Developer to elevate the web UI/UX experience for our users.
Ideally:
1. You are highly skilled in accessible and semantic #HTML 2. Proficient in modern #CSS 3. Experienced with #Javascript, #Typescript and complex React/Redux applications
This remote full-time position requires a 4-hour overlap with the CET timezone.
Our core team is looking for a senior Front-end Developer to elevate the web UI/UX experience for our users.
Ideally:
1. You are highly skilled in accessible and semantic #HTML 2. Proficient in modern #CSS 3. Experienced with #Javascript, #Typescript and complex React/Redux applications
This remote full-time position requires a 4-hour overlap with the CET timezone.
Our core team is looking for a senior Front-end Developer to elevate the web UI/UX experience for our users.
Ideally:
1. You are highly skilled in accessible and semantic #HTML 2. Proficient in modern #CSS 3. Experienced with #Javascript, #Typescript and complex React/Redux applications
This remote full-time position requires a 4-hour overlap with the CET timezone.
Our core team is looking for a senior Front-end Developer to elevate the web UI/UX experience for our users.
Ideally:
1. You are highly skilled in accessible and semantic #HTML 2. Proficient in modern #CSS 3. Experienced with #Javascript, #Typescript and complex React/Redux applications
This remote full-time position requires a 4-hour overlap with the CET timezone.
Calflora is seeking an experienced developer who would like to take part in important conservation work and who values biodiversity data. This developer would assist in maintaining and developing Calflora’s Java-based website and infrastructure, including systems administration, database management, web application programming, front-end development, and data integration. Qualifications: Java - Databases (MySQL or other), Java-based web technologies (such as GWT), and interest in natural history and botany. https://myemail.constantcontact.com/The-Calflora-Team-is-Expanding-.html?soid=1101318247526&aid=vnjMtGwmYG4. #jobs#javascript
Our core team is looking for a senior Front-end Developer to elevate the web UI/UX experience for our users.
Ideally:
1. You are highly skilled in accessible and semantic #HTML 2. Proficient in modern #CSS 3. Experienced with #Javascript, #Typescript and complex React/Redux applications
This remote full-time position requires a 4-hour overlap with the CET timezone.
Our core team is looking for a senior Front-end Developer to elevate the web UI/UX experience for our users.
Ideally:
1. You are highly skilled in accessible and semantic #HTML 2. Proficient in modern #CSS 3. Experienced with #Javascript, #Typescript and complex React/Redux applications
This remote full-time position requires a 4-hour overlap with the CET timezone.
Our core team is looking for a senior Front-end Developer to elevate the web UI/UX experience for our users.
Ideally:
1. You are highly skilled in accessible and semantic #HTML 2. Proficient in modern #CSS 3. Experienced with #Javascript, #Typescript and complex React/Redux applications
This remote full-time position requires a 4-hour overlap with the CET timezone.
Our core team is looking for a senior Front-end Developer to elevate the web UI/UX experience for our users.
Ideally:
1. You are highly skilled in accessible and semantic #HTML 2. Proficient in modern #CSS 3. Experienced with #Javascript, #Typescript and complex React/Redux applications
This remote full-time position requires a 4-hour overlap with the CET timezone.
Our core team is looking for a senior Front-end Developer to elevate the web UI/UX experience for our users.
Ideally:
1. You are highly skilled in accessible and semantic #HTML 2. Proficient in modern #CSS 3. Experienced with #Javascript, #Typescript and complex React/Redux applications
This remote full-time position requires a 4-hour overlap with the CET timezone.
Our core team is looking for a senior Front-end Developer to elevate the web UI/UX experience for our users.
Ideally:
1. You are highly skilled in accessible and semantic #HTML 2. Proficient in modern #CSS 3. Experienced with #Javascript, #Typescript and complex React/Redux applications
This remote full-time position requires a 4-hour overlap with the CET timezone.
Our core team is looking for a senior Front-end Developer to elevate the web UI/UX experience for our users.
Ideally:
1. You are highly skilled in accessible and semantic #HTML 2. Proficient in modern #CSS 3. Experienced with #Javascript, #Typescript and complex React/Redux applications
This remote full-time position requires a 4-hour overlap with the CET timezone.
Our core team is looking for a senior Front-end Developer to elevate the web UI/UX experience for our users.
Ideally:
1. You are highly skilled in accessible and semantic #HTML 2. Proficient in modern #CSS 3. Experienced with #Javascript, #Typescript and complex React/Redux applications
This remote full-time position requires a 4-hour overlap with the CET timezone.
Our core team is looking for a senior Front-end Developer to elevate the web UI/UX experience for our users.
Ideally:
1. You are highly skilled in accessible and semantic #HTML 2. Proficient in modern #CSS 3. Experienced with #Javascript, #Typescript and complex React/Redux applications
This remote full-time position requires a 4-hour overlap with the CET timezone.
Our core team is looking for a senior Front-end Developer to elevate the web UI/UX experience for our users.
Ideally:
1. You are highly skilled in accessible and semantic #HTML 2. Proficient in modern #CSS 3. Experienced with #Javascript, #Typescript and complex React/Redux applications
This remote full-time position requires a 4-hour overlap with the CET timezone.
Our core team is looking for a senior Front-end Developer to elevate the web UI/UX experience for our users.
Ideally:
1. You are highly skilled in accessible and semantic #HTML 2. Proficient in modern #CSS 3. Experienced with #Javascript, #Typescript and complex React/Redux applications
This remote full-time position requires a 4-hour overlap with the CET timezone.
Our core team is looking for a senior Front-end Developer to elevate the web UI/UX experience for our users.
Ideally:
1. You are highly skilled in accessible and semantic #HTML 2. Proficient in modern #CSS 3. Experienced with #Javascript, #Typescript and complex React/Redux applications
This remote full-time position requires a 4-hour overlap with the CET timezone.
#ReleaseFriday (1st release cycle of 2025) 🎉 — New additions & updates to https://thi.ng/genart-api, a platform-independent extensible API for browser-based computational/algorithmic/generative art projects:
- Added https://fxhash.xyz platform adapter (incl. support & adaptations for 10 of the 17 built-in GenArtAPI param types) - Added `bigint` & `binary` data param types - Updated parameter type definitions & factories (date, datetime, time, numlist, strlist, text, vector) - Ensure any given default values are valid (and can be coerced) - Added MurmurHash3 (128 bit version) functions (e.g. seed PRNGs) - Added tests for all parameter types (factory functions & implementations) - Added tests for utility functions - Added GitHub actions (running tests) - Various API docs updates, clarifications & fixes - Update/refactor EditArt & Layer platform adapters - Updated main & adapter readmes
I just noticed the release notes for @gotink’s #JavaScript#KDL parser and it has this new tool for defining KDL<->JS mappings in a more complex way than just JiK. This is AMAZING. It lets you really harness the power of KDL’s node-based system but still work easily with JS objects, in a well-defined and structured way!
Cause sometimes what you really really want is a tree structure, not just objects and arrays. And you never want yaml, even if you think you do :P
Next month #ThingUmbrella will be already 7 years old (in its current monorepo form) and thi.ng itself turn 14 — a true teenager! 😱
2024 has been a year of a lot of maintenance and the first year in a while, in which I got to put so many of these tools & libraries to work on the development of several other new (and ongoing) projects (incl. some still unannounced ones). Considering the vastly different usage contexts, each time this is also a demonstration (to myself) of just how powerful, adaptable and _composable_ many of these libraries are, and I wish I'd be able to better communicate these aspects to other people...
My deepest thanks and gratitude to my amazing supporters/sponsors, who've been enabling me to continue this work, to expand on it and actively maintain it! Some of you already for years! Love you, people — Your support means the world to these projects (and to me)! And even though I'm still a far way from being able to work fulltime on all these projects, and also had to take on some consulting work this year, I too have been trying my best to work on thi.ng projects every day this year (and almost succeeded)...
- 200 packages/libraries/tools - 180 standalone example projects/tools - 520 code snippets/examples in docs (extractable via tooling)
Source code:
- 4,095 source files - 223k SLOC total, of which: - 159k lines of code - 64k comment lines (mostly for API docs)
Readme's:
- 33% of packages with 1,000+ words - 20% of packages with 1,500+ words - Min: 215, max: 9,519, avg: 1,075 words
3,445 Github ⭐️ (+12% in 2024)
200,675,881 NPM total downloads to date (🤯)
There're many valuable ways to support these projects: Share your usage/experience reports, tips & tricks, ask/answer questions, submit issues/PRs, create small examples, documentation/tutorials, word-of-mouth etc.
If you see value in these projects and want to support a large & mature body of open source work financially, I'm accepting contributions via: Github, Liberapay & Patreon — thank you very much for your consideration!
ALT text detailsScreenshot of my Github activity/contribution heatmap of the past year, listing 2493 contributions (only a handful of days without contribs since end of Jan 2024)
Visualization from here:
https://github.com/postspectacular
Next month #ThingUmbrella will be already 7 years old (in its current monorepo form) and thi.ng itself turn 14 — a true teenager! 😱
2024 has been a year of a lot of maintenance and the first year in a while, in which I got to put so many of these tools & libraries to work on the development of several other new (and ongoing) projects (incl. some still unannounced ones). Considering the vastly different usage contexts, each time this is also a demonstration (to myself) of just how powerful, adaptable and _composable_ many of these libraries are, and I wish I'd be able to better communicate these aspects to other people...
My deepest thanks and gratitude to my amazing supporters/sponsors, who've been enabling me to continue this work, to expand on it and actively maintain it! Some of you already for years! Love you, people — Your support means the world to these projects (and to me)! And even though I'm still a far way from being able to work fulltime on all these projects, and also had to take on some consulting work this year, I too have been trying my best to work on thi.ng projects every day this year (and almost succeeded)...
- 200 packages/libraries/tools - 180 standalone example projects/tools - 520 code snippets/examples in docs (extractable via tooling)
Source code:
- 4,095 source files - 223k SLOC total, of which: - 159k lines of code - 64k comment lines (mostly for API docs)
Readme's:
- 33% of packages with 1,000+ words - 20% of packages with 1,500+ words - Min: 215, max: 9,519, avg: 1,075 words
3,445 Github ⭐️ (+12% in 2024)
200,675,881 NPM total downloads to date (🤯)
There're many valuable ways to support these projects: Share your usage/experience reports, tips & tricks, ask/answer questions, submit issues/PRs, create small examples, documentation/tutorials, word-of-mouth etc.
If you see value in these projects and want to support a large & mature body of open source work financially, I'm accepting contributions via: Github, Liberapay & Patreon — thank you very much for your consideration!
ALT text detailsScreenshot of my Github activity/contribution heatmap of the past year, listing 2493 contributions (only a handful of days without contribs since end of Jan 2024)
Visualization from here:
https://github.com/postspectacular
I have added snow to my instance during the winter holidays. It's a tiny JS canvas and fades out on scroll down. The snow is also respecting the system accessibility settings, it won't be there if you prefer reduced motion.
Another new release of #GenArtAPI (v0.20.0), due to some urgent additions & updates of partially outdated documentation and refactoring/cleaning up of some parameter types. This project already contains more docs than code and because things are moving so fast, I forgot to update some parts... (Sorry for any confusion caused...)
Other notable updates:
- Simplified the core API's param value getter for obtaining time-based or randomized values (please check docs[1]) - Updated vector param definition - Added a `.configure()` method for the EditArt platform adapter to allow manual selection of adapted params (to override the default auto-selection)[2]
All implementations are WIP (but fully functional, to the best of my knowledge!). If there's demand, I'm considering adding more parameter type adaptations also for the EditArt adapater (e.g. to support vector/XY params, as already done for the Layer adapter...)
Since I've been told "people/artists don't read anymore", tonight I'm starting to record a video walkthrough, wish me luck! :)
I want to give huge thanks to everyone who supported all of us through this, who jumped in and had some really amazing discussions weighing all sorts of interesting trade-offs.
The end result is absolutely not something any one person could've reasonably come up with.
I hope y'all enjoy it <3
As part of this release, several implementations have already launched with full support for v2.0.0, so you can try it now!
There are around 8k .kdl files out on GitHub, which is a lot considering it's usually a config language!
I fully expect this to be the last version of KDL ever released. We really really tried, but I don't think there's anything we can reasonably improve on.
From here on out, the language is in the (stable!) hands of the ecosystem.
Also, we're hoping to have GitHub syntax highlighting support soon!
(Boosts welcome!!)
ALT text detailssyntax-highlighted zellij config ported to 2.0.0 format.
// This config is just like `zellij.kdl`, except it shows what it would look
// like if modifiers were done using `+` instead of spaces (thus needing to be
// quoted).
keybinds {
normal {
// uncomment this and adjust key if using copy_on_select=#false
/- bind Alt+c { Copy }
}
locked {
bind Ctrl+g { SwitchToMode Normal }
}
resize {
bind Ctrl+n { SwitchToMode Normal }
bind h Left { Resize Left }
bind j Down { Resize Down }
bind k Up { Resize Up }
bind l Right { Resize Right }
bind "=" + { Resize Increase }
bind - { Resize Decrease }
}
pane {
bind Ctrl+p { SwitchToMode Normal }
ALT text detailsa section of a syntax-highlighted example KDL document based on a GitHub Actions yaml configuration, ported to KDL 2.0.0.
steps {
step uses="actions/checkout@v1"
step "Install Rust" uses="actions-rs/toolchain@v1" {
profile minimal
toolchain "${{ matrix.rust }}"
components clippy
override #true
}
step Clippy { run cargo clippy --all -- -D warnings }
step "Run tests" { run cargo test --all --verbose }
step "Other Stuff" run="""
echo foo
echo bar
echo baz
"""
}
This proposal could help with the following problem—quoting Tzvetan Mikov (Static Hermes): “Unfortunately, in general it is impossible to compile JS statically to a tiny binary (Wasm or otherwise), because it is impossible statically to know which parts of the JS library are used.” https://x.com/tmikov/status/1869900344286949425
New release of https://thi.ng/genart-api, a modular cross-platform API/SDK for browser-based computational/algorithmic/generative art projects, helping to reduce artists' efforts to adapt work for different art platforms/environments/uses/workflows.
Main new v0.18.0 additions:
- The param editor reference implementation now groups parameters by their declared group and sorts them by given order (both optional) - The `@genart-api/adapter-layer` package supports adaptations/translations for more param types, incl. vectors, which are not yet natively supported by that platform. E.g. vectors will be transparently represented as multiple, separate numeric params on the platform side, but your artwork is blissfully unaware of this and still only would deal with vectors. The platform adapter does all the reconcilation and handling of param changes... - Started adding tests - Updated API docs & readme's
As always, feedback highly appreciated — this project is in active development...
I'm aware, the target audience for this larger project is quite limited, but the benefits are real (and palpable!), not just for artists in this field (but especially for them!)... I'll do my best to illustrate the (recurring) problems being solved here, demystify some of the concepts and squeeze in recording a short(ish) video showing how to develop a small project from scratch using this system/setup and then repurpose it and show related tools still in development...
$ pip3 search something ... RuntimeError: PyPI no longer supports 'pip search' [...]. Please use https://pypi.org/search (via a browser) instead. [...]
Sure, no problem. Let's see …
»JavaScript is disabled in your browser. Please enable JavaScript to proceed.«
Urgh, but okay, #pip is a #Python package manager, they're good guys. Let me just open #NoScript and temporarily allow pypi.org ... oh no, it wants to run #JavaScript from …
there is now another #KDL implementation that supports preserving and managing formatting/comments... and it's in #JavaScript / #TypeScript and supports 2.0!!
- https://thi.ng/ramp has just received a bugfix for ramps with more than 256 keyframes. Thanks to @robertoranon for finding & reporting! 🤩🙏 - https://thi.ng/meta-css also fixes a couple of issues related to using certain characters within template/macro arguments (e.g. `:`, `=`)
Last week, I also added a new feature to https://thi.ng/rstream to provide a 1:N fanout subscription type for reactive tuple values. For example, this is very useful for editing vector values via reactive UI components (using individual components per vector/tuple element)...
- Added platform adapter IDs for use with external editors/tooling - Updated editors[1] to check for platform adapter & API version compatibility, display warnings if needed... - Added/migrated three different seedable PRNG implementations in API core package (SFC32, XorShift128, XsAdd). These are completely independent and can be used by platform adapters and/or artworks (also multiple instances) - Initial release of first platform adapter for an upcoming art platform (currently invite only) - Restructured all example projects - Updated readme & API docs (https://docs.thi.ng/genart-api/core/)
[1] The param editor/sandbox requires your artwork to use the latest version of these packages: `@genart-api/core` and `@genart-api/adapter-urlparams`.
Almost each time I get a Dependabot alert, I've been using it as an opportunity to remove some 3rd party dependency. This doesn't mean my code is more secure (albeit I'm trying), but at least it's under my control, or is replaced with more native/built-in/vetted packages.
Latest case: An alert for a transitive dependency of `express` just caused me to refactor the only one (of 180) example projects in https://thi.ng/umbrella which depended on the latter, replaced with a barebones NodeJS built-in solution (good enough for this use case) and resulting in ~60 less dependencies in total...
I like that @deno_land tries to be an all-in solution. I like that about go as well. Good tooling, rich standard library. What is difficult, though, is that the js ecosystem is so fragmented. For instance, I’m trying to use drizzle ORM with SQLite. That’s far from straightforward. They don’t include examples for Deno. Translating commands to how Deno likes them is a hassle and I run into issues with migrations #development#javascript#deno
- Restructured the project as monorepo, splitting out core API and platform adapter(s) as separate packages - Switched package scope from `@thi.ng` to `@genart-api` to highlight project/platform independence (not directly related with other thi.ng projects). - Published new packages: `@genart-api/core` and `@genart-api/adapter-urlparams` - Moved API docs to https://docs.thi.ng/genart-api/core/ - Added support for n-dimensional vector parameters and added support in the reference platform adapter and in param editor - Updated all examples & parameter editor. The latter is now only compatible with this latest API version (v0.16.0) - Updated docs/readme
If you want to find out more, the project readme has _a lot_ more information. Also feel free to get in touch with any questions/proposals!
Update on #FreeJavaScript: Oracle has filed a notice of appearance, signaling engagement in the JavaScript trademark case. Aside from this, we’ve had no communication. Their response is due by January 4th.
Many very talented software engineers I know well from a previous employer have either just been layed off or are actively looking for a new gig due to these mass layoffs. If you know a company, preferrably in Germany, that is looking for #javascript#typescript developers, please let me know. Please boost for reach! #getfedihired
It just dawned on me that I haven't been mentioning five(!) recent https://thi.ng/genart-api updates, all from the past month... 😱
The latest version (v0.14.0, just released) is largely about an overhaul of messaging related functionality and also addresses use cases related to managing multiple artworks embedded (via `<iframe>`s) in a single document/page (think: online gallery scenarios...)
If you're already using GenArtAPI message/event listeners in your own artwork, you might have to rename some of them. This commit has the important details:
Also, the online parameter editors have been updated and are now only working with the latest version of the API, so be sure to update your artwork projects to stay compatible:
Other recent changes/additions (in no particular order):
- added new message types to poll the artwork/API for current state/info - update message names & naming convention - added ability to configure the API behavior/features (also via messaging) - option to emit frame messages w/ current timing/frame info - message broadcasting to multiple GenArtAPI instances/artworks - inject common defaults for optional settings in param specs - fixed date/datetime param handling (in editor) - updated/fixed time providers - updated debug time provider (w/ FPS visualization overlay) - use gzip compression for image param values (in default platform adapter) - added version info - various documentation updates - (WIP) WASM bindings for Zig-based artworks - (WIP) unpublished progress on real platform adapters
Some of these features are all about enabling new use cases and improving usability of external tooling around artworks adapting GenArtAPI, for example:
- Ability to broadcast start/stop messages to either individual or all artworks embedded in a page - Ability for the param editor to configure the artwork currently being worked on to emit timing & frame information (which then can be integrated in the editor UI without the editor knowing anything else about the artwork) - Enable editors to identify an artwork/project and store param presets grouped by project ID - Allow editors (or other tools) to check the API version used by the artwork by first sending a `genart:get-info` message, then listening for `genart:info` response (then maybe display a warning if version is incompatible) - etc.
If you want to find out more, the project readme has _a lot_ more information. Also feel free to get in touch with any questions!
"It insists that all user problems will be solved if teams just framework hard enough." (article about #javascript) but this THIS is the single one reason for me about #go - a standard library well stocked enough to not need frameworks anymore but instead choosing a small selection of really necessary libraries and a lil' sugar for any given project. I didn't framework hard the last decade - I didn't framework at all. (and its simplicity.) https://infrequently.org/2024/11/if-not-react-then-what/
@slightlyoff I've being doing this for so long (#webdev). I have an inkling that everytime this conversation comes up and the person doing the "front end frameworks are killing us" cautioning - can't or won't actually recommend an alternative - it's because it will never be possible.
Not until the JS baked directly into the browser stops sucking so badly.
It's bandaids on top of wounds on top of bandaids.
We’ve submitted a formal petition to cancel the JavaScript trademark: it is generic, Oracle has abandoned it, and Oracle committed fraud on the USPTO during the last trademark renewal.
Oracle has until January 4th to respond, or the case will go into default, which will result in the trademark being canceled.
Very much liking the succinctness of the JS Compression Streams API[1] and wish I'd known about this a couple of years earlier. Here're some small helpers to compress or decompress a byte array...
I've just also pushed a new version of https://thi.ng/genart-api (v0.11.0) in which the reference implementation platform adapter now uses gzip compression for serializing the data of image maps/parameters (in ~50-60% of the original size)...
- Added null pointer checks & guards in https://thi.ng/wasm-api. This also includes support for structs with fields using Zig-style optional pointers. - Updated the https://thi.ng/wasm-api-bindgen code generator for #TypeScript to produce smaller code for structs using many string fields - Did major ground work on #Zig#WebAssembly bindings of core https://thi.ng/genart-api functionality (see small demo below) - Fixed/updated/simplified time provider logic - Updated the debug time provider with its FPS analytics/visualization overlay, now computing moving min/max and moving average (default period = 200 frames) and the viz is dynamically/smoothly rescaling to current peak - Released new GenArtAPI v0.9.0
As for the Zig/WASM example: This is only interesting from a technical POV, no visuals here! All canvas drawing and parameter declarations/evaluations are done via Zig, using the aforementioned https://thi.ng/wasm-api infrastructure to provide a new API module which can be seamlessly used with the other hybrid WASM API modules, here for DOM creation (https://thi.ng/wasm-api-dom) and to handle Canvas2D drawing (https://thi.ng/wasm-api-canvas).
At the moment, this GenArtAPI WASM module is still a fixed part of this example, but will eventually be extracted & distributed as separate package.
Choose one of the two GUI implementations, then make any parameter changes and you should see the new values applied immediately (btw. the demo is likely not very usable on mobile)...
I'm a bot, now on a new instance at https://front-end.social/! If you're already following, the transition should happen automatically. However, if you have any bookmarked posts, I recommend re-bookmarking the direct links to articles in your browser for safe keeping.
Starting December 15th, the original instance will no longer be active. I'll send a reminder before then.
Really enjoying adding end-to-end tests to Kitten¹ using Playwright² and my own little Kitten controller class for starting/stopping/otherwise interacting with the Kitten server.
Just wrote some that comprehensively test identity creation and authentication for Small Web places:
https://thi.ng/genart-api is already at v0.8.1 now. This latest version includes a new "debug mode" time provider plugin which also collects and computes frame rate statistics (moving average) and injects a canvas visualization overlay (everything configurable). Together with the parameter editor, this is a small, but useful tool to help configuring an artwork and ensure fluid performance on a target device/platform...
https://thi.ng/memoize: Function memoization/caching. Added support for async functions/promises and made existing implementations variadic (and removed fixed arity versions!). This is thanks to a feature request by Hitomi Tenshi...
https://thi.ng/transducers-stats: Functional sequence processing. Added moving minimum/maximum transducers (deque-based to be super efficient) and updated Donchian channel transducer (aka moving min/max bounds) to also benefit from new implementation
There's also ongoing major (re)work of the long-promised 2D/3D mesh implementation. It's still on a private feature branch, but I'm getting closer for initial release...
I got kinda obsessed with mazes recently and made a tool to generate infinite random mazes. I wrote an article about how it works and created animated visualizations of the process.
"What are the effects of component-based architectures? They mean that developers no longer have to know HTML to write HTML. When it comes to accessibility, this is not a good thing. The vast majority of accessibility lives in the markup. Not understanding which elements to use or what is even valid to do in the language is always going to cause accessibility barriers."
Just released #LogTape 0.7.0 with implicit contexts! Now you can automatically include request IDs, user IDs, and more in your logs without passing context manually. Read more about this powerful feature:
👋 I’ve been a developer for about 24 years. The last 10+ I’ve been working in #DevRel roles, currently at LaunchDarkly as a Developer Experience Engineer.
I’m active in the developer community as a speaker, author & organizer. I speak a lot on topics like #WebDev, #JavaScript, #Jamstack & #Serverless. I co-wrote multiple books on Jamstack and run a newsletter on the topic. I organize virtual events on cfe.dev & run the Orlando Devs #meetup.
Thought it might be fun to make a small jsr package that actually has a bit of real-world utility. So here's `isit` as in `isit("Friday") ? "Hooray!" : "Boo!"` which I'll use in our morning work standup bot to send a different Teams meeting link depending on what day it is. Maybe it'll be useful to someone else too. It supports custom Dates and timezone offsets too. Enjoy! https://jsr.io/@phocks/isit
I should probably make a proper #introduction post. So guess now is fine?
Hello! I am Ari Archer. I am an #LGBT 17-year-old #OpenSource#Autistic developer from #Lithuania who likes to mess around with #software, #backend development, and of course my favourite #programming languages: #C (ANSI #C89 is my favourite C standard) and #Python :) I can fuck around in Assembly too, although I tend to think it's not practical in most cases, although I don't do that much low level programming for it to matter, I do enjoy occasional #ProgrammingLanguage development, though.
I have a (shitty) #website on https://ari.lt/ (which I need to re-re-re-write (I need to rewrite it for the 3rd time, the 2nd time was fine I think, but I kinda made it bad now ;-; because it's basically all #JavaScript), I also have a #blog at https://blog.ari.lt/ which I post random #thoughts, #progress, #tutorials, #recipes, etc. on, could I call it #lifestyle content? I don't know. I also like #cats (and I have one named Tina and I love her very much), #cooking, and #researching random things which I yap about to my friends.
I am very pro-#selfhosting and feel like more people should do it, maybe not anything large or mainstream, but at least try to, #learning about things is fun, and self-hosting teaches you a lot, as well as making it easier for people to migrate to #foss easier, which I believe to be a good thing. Most of my beliefs are centred around "by people for people" as in everything should be accessible, open source, and #free as in #freedom.
I hope I enjoy my stay on #fedi these days as I haven't really been on fedi for a while now, in the mean time you can reach me on #email (ari@ari.lt), #matrix (@ari:ari.lt) or #Git/#GitHub (https://ari.lt/gh).
Greetings, Program! I'm Evan (he/him). I live in the #Portland area.
I'm an Engineering Manager with a technical background in #javascript and #frontend, and I believe putting people first is the key to making good software.
I’m a dad to three very energetic young kids, I’m a #coffee enthusiast, I like playing #videogames, taking #photos, and I enjoy #cooking when I can make the time for it.
Who me? Just a #Maker, IT Consultant and "all-around-#nerd".
I grew up watching Saturday morning cartoons, original #StarTrek re-runs, reading #Fantasy & #SciFi (not SyFy), lots of #Lego and eventually graduated to #RPG and #tabletop gaming.
My first computer was a #Commodore Vic-20 - at school, we learned graphical #LOGO on PETS and Apple IIe's... crashed the Unisys ICON network often before getting my first PC - grudgingly - really wanted an #Amiga.
Eventually, it was time for college - I *thought* I would be heavily involved in the physical aspects of technology, circuit design, and hardware engineering - instead, I gravitated to #programming.
At some point, you write something yourself. In this case, a JavaScript solution to unite blog posts with their interactions on the #socialweb and beyond...
- added two list param types (numeric & string) - added support for composite/nested param types, esp. interesting for custom param types declared by artworks and/or platforms - updated the first (of two) GUI param editors in the reference implementation to support composite params - added new example showcasing custom & composite param types (oscillators)
To explain a bit further: The example defines a custom oscillator parameter type, which itself consists of multiple sub-params to configure waveform, frequency, amplitude etc. Using the GenArtAPI messaging protocol, the external param editor (not knowing anything about the artwork or this custom param type) can still provide GUI widgets to customize the 2 oscillators used... Likewise, the artwork is completely decoupled from how those oscillator values are being computed or how they're customized via the editor...
If you've been avoiding #JavaScript & #TypeScript due to the complexity of the #Node.js ecosystem, give #Deno a try. Everything is simplified and you can start coding right away without having to set up a development environment.
If this was built with a framework the framework wouldn't even be loaded yet. This doesn't even lazy load any JS. There is just so little of it that I load it in <head/>. Each stone is an html element AND each stone placement has to calculate quite a bit before it can move on.
Henlo frens, i have completed my basic studies of HTML and CSS with the help of a local school, now i begin studying Javascript.
But between the JS studies, i want to practice my HTML and CSS skills, what would be the best way to do that?
I believe that trying to clone existing websites would be a cool way to upskill. Do you know of any particular website(s) that i should try and clone as a beginner? I have once worked with cloning amazon.com.
What else can i do as well? I want to focus on styling and structure as well.
Lots of new additions & improvements to the https://thi.ng/genart-api proposal, documentation, the reference implementation, examples and param editors this week:
- added new (12th) parameter type: image maps (supporting grayscale or RGB) - added new example project using an image parameter to create artwork - added code example showing how an art platform (or artwork itself) might define & work with a custom parameter type (example: sine oscillator) - added/updated API docs (https://docs.thi.ng/umbrella/genart-api/) - started documenting API states & transitions (diagram still WIP, forthcoming) - initial documentation of message protocol (for communicating w/ parent window and/or external tooling) - simplified the pluggable time provider implementations (for animation) - updated the reference implementation platform adapter to support all built-in param types - major update GUI param editors, now allowing users to dynamically load & customize externally hosted (compatible!) artworks, and also supporting image params, custom color chooser component...
ALT text detailsScreenshot of the linked image map parameter example, showing a sidebar with different parameter controls (low res grayscale image preview, color picker), and the artwork showing the imported image represented as a fine grid of differently sized pink dots on dark blue background
Hello World! Alex Standiford here. I am a web developer at GoDaddy, who travels full-time in one of two RVs with my two kids, two cats, a dog, and my wife. I mostly talk about #travel, #WordPress, #RVlife and bad puns. Looking forward to meeting y’all!
With zero-overhead bindings to V8 APIs, memory safety through Rust’s ownership model, and great docs, it’s battle-hardened and production-ready. From here on, Rusty V8 will follow Chrome versions for predictable upgrades.
#LogTape v0.6.0, a zero-dependency structured logging library for #JavaScript & #TypeScript, has been released. The main changes include:
• Loggers now can override sinks of their ascendants. • Placeholders in message templates now forgive leading and trailing spaces. • Added LogRecord.rawMessage property. • Built-in text formatters now can be customized.
Today's #FediJam update: pixel graphics by @misnina are in, collectible placement is (probably) finalized. I'm very happy with how this looks now! 🙂
1.5 weekends to go before the jam ends, core gameplay and visuals more or less done, lots of auxiliary stuff left: light story content, sound effects, end screen, title screen and menus, options, credits, touch controls, ...
(Marked sensitive in case you'd like to avoid spoilers)
ALT text detailsA blue feather floats across a cloudy sky. A red pinwheel (controlled by the player's mouse cursor movement) propels it around softly. Clusters of silvery letters float in the sky, some of which the feather collects by getting close to them. Everything is rendered in 2D pixel art, except the letters, which are small 3D objects.
‣ Add `process` global variable, remove `window` ‣ Improve dep management ‣ Permission system updates ‣ Many stabilizations ‣ Better CommonJS support ‣ Test documentation with `deno test --doc`
I'm looking for a #JavaScript / #NuxtJS developer to help me extend my FastAPI/NuxtJS template (https://github.com/whythawk/full-stack-fastapi-postgresql) to support #ActivityPub. I'm busy with the #FastAPI server. My objective is an open source starter template for developing full federated apps for creator commercial activity (like a personal Etsy or Amazon site) where creators can sell their work & supporters can follow for new product releases. This is a paid project. Contact me direct. #FediHire
Since there has been a huge influx of new users, I decided to write a new #Introduction and actually pin it to my profile. I'm pushing 50 years old and I live in a Red State that is trying to make me illegal. I'm a #pansexual / #bisexual#transgender woman married to a heterosexual cisgender woman who frequently talks about the current hellscape for people like me in my Toots. I'm #NeuroDivergent / #ND which is probably why all of these sentences start with "I". I've worked in #InfoSec for a little over 20 years. I've had lots of roles in #SecEng, #SecOps, and #ThreatManagement. I taught myself #Perl, #Bash, #SQL, and #PowerShell. I'm decent at #JavaScript. I can read #Python and #Ruby. I enjoy automating things and turning manual processes into scripts. I've been the primary #CareGiver to my wife for 8 years since she developed a chronic condition and went on disability. My hobbies including #writing#paranormal short fiction, journaling my #dreams, and playing #PCGames on my laptop and #SteamDeck. I prefer #StarGate over #StarTrek over #StarWars. Still waiting for Amazon to do something, anything with the Stargate property. While we loved the #ArrowVerse including #Stargirl and #SwampThing, in general we prefer #Marvel over #DC. I'm a fan of #Horror / #HorrorFam, #HorrorMovies and #HorrorBooks, especially the existential dread of #CosmicHorror or #LovecraftianHorror. I tend to sympathize with the nameless terrors. I am not a fan of mindless slashers, unrelenting gore, or torture porn. Over-the-top, egregious gore that crosses into the absurd is fine, though, so I am a Sam Raimi fan, obvs. Also, #HorrorComedies are underappreciated. I'm slowly reconnecting with my #Pagan roots. I knew some stuff about #Tarot and had a friend who as a tree a lifetime ago and I'm trying to rekindle that. We've got #Cats and they are our kids. I also happen to love #Frogs, but we don't have any of those.
Unveiling the core gameplay loop of my #FediJam entry. 😀 Think you can do better than me? You're probably right! Prove it next month!
Note: still placeholder graphics, have not even started on presentation except basic animation. I wanted to get the movement nailed down early since it's so core to the experience. This feels about right.
(Gonna be marking these as sensitive in case people want to avoid spoilers.)
ALT text detailsA red pinwheel, controlled via mouse movement, softly blows a black feather across a cloudy sky which the camera is slowly panning across. Some purple cubes are jiggling in the sky, the feather collects some of them through close contact. The collected cubes shrink and start rotating around the feather.
My name is Austin and I love my family, Sports, Music, and Tech.
I am a software developer at #PayTheory. At my job currently I work primarily with #Javascript, #React, and #Python. I know some #Swift and hope to publish an app in the AppStore in 2023. I am going to try to #BuildInPublic here.
Finally starting on my #FediJam project today. 😀 Because is it a real deadline if you don't start on the thing halfway through? 😇
This is after an hour or two of getting warmed up again in #threejs. Hand-fudged physics, no graphics yet, but you can guess at the basic gameplay concept. I'm having fun so far!
ALT text detailsA gray rectangle floats in a blue void. A red spinning square appears, controlled by mouse movement, moves around the screen and softly pushes the rectangle around like a repelling magnet.
Acerca de mí: #introduction#presentation ¡Hola! Soy Mónica Gómez, también conocida como Autumn64. Soy una estudiante mexicana de Ingeniería en Sistemas Computacionales, soy una mujer transgénero y soy activista por el movimiento del #Software_Libre.
En redes me dedico a la promoción y difusión del Software Libre, así como de sus ventajas técnicas y éticas desde el punto de vista latinoamericano e hispanohablante.
Esta es mi cuenta principal, y además tengo otras cuentas en el #Fediverso. Si quieres verificar que realmente soy quien digo ser, por favor revisa mi clave pública: https://www.autumn64.xyz/src/es/key.html
It has two fun new shape styles, a bunch of added logos (👋 @pixelfed@joinpeertube@Codeberg@forgejo and more), some advanced options for turbo nerds, and irregularly shaped logos now get better cutouts.
I think this covers most of the feature requests I've received. 😀
it's been a while and there's new folks on here so here's my #Introductions post again
Hey there! I'm Aode (or Chad or Tavi or asonix or Arlo or...)! I'm a lion or eevee or other lion or dog or hyena or on the internet on my small personal server on here. pronouns are He/They
I'm a big #WarriorCats fan although I haven't read the most recent series yet (or a couple novellas and super editions before then) but i've read most of the books!!!
There is one thing keeping me from switching to Firefox full time: the Chrome UI sounds extension. It makes a sound every time a new page loads or content updates. It's super helpful as a screen reader user when navigating very complex web apps. I tried repacking it for Firefox, but it won't run without some work. I'm looking at the sourcecode to see if I can make it work, but this is well outside my comfort zone. Anybody have resources for porting extensions from Chrome to Firefox?
I’ve been on here a while but never wrote an #introduction post so here it is.
My name is Mark thought most people call me JR (J.R. not “junior”). I am a believer and follower of Christ. My passion is #software#engineering and I’ve been at it professionally for over 14 years. Though I mostly develop for the web I enjoy working with the #fullstack including the hardware and architecture of it.
haven't done as much coding in d3 as i used to, but i just wanna point out how great it is that we have a data visualisation tool like this that is free and open source. check it out if you haven't already https://d3js.org
I’ve been fascinated by the #web since I first got on the internet when I was a teenager. The idea that anyone could create a website — how cool is that!?
I’ve been a #Mac user even longer (my parents were in education and my mom would bring home her office Mac Classic on the weekends). Being creative with #HyperCard and wanting to make dynamic websites eventually got me into #programming. First with #Perl, later #PHP, and now #JavaScript and #TypeScript. I’ve also had some fun with #C, #ObjectiveC, and #Swift.
For 14 years I worked at a small company that makes the premier CMS for the #AltWeekly press in the US. Now I work on web applications in #React in the far-more corporate world. I also used to co-organize TucsonJS and Tucson React meetups.
I'm a #softwaredev focusing on #javascript & #typescript specifically #deno. Right now, I'm working on a blog called Craig's Deno Diary. I also contribute to a few Deno projects and am taking a break from working in the corporate world.
I have over 20 years of experience in web development, first using Java and recently JavaScript/TypeScript. Before that I was a #journalist for 10 years.
I live in #Maine USA & try to enjoy the beautiful environment here as often as possible.
Some new #passkey capabilities are being added to #Chrome after a careful standardization work by the community. - Hints: allow you to control #authentication UI, especially when you want to focus on security key or cross-device authentication. - Related origin requests: allow passkeys to work on related but different origins. - JSON serialization: simplifies your #JavaScript code with binary encoding and decoding.
There is a fundamental difference between #complexity for the sake of convenience (I can build an entire app quickly. Think #JavaScript framework of the day), vs complexity for the sake of robustness (I can make changes to the app quickly without introducing new bugs. Think #Rust or #Haskell).
When you are not familiar with the tech, both can look the same, but they are not. The latter is actually #simplicity in disguise
I currently work at the Icelandic Met Office as a #GIS Coordinator in #Reykjavik. In general, I help people make maps, find #geodata either with code (#python or #javascript) or with desktop software like #QGIS
I love the outdoors and enjoy hiking, climbing and biking. I've been involved with Icelandic Search & Rescue for many years, both on the frontline (mountain rescue) and as an instructor for new team members.
Father of twins since 2016
ALT text detailsFamily of 4 on a picknick in Iceland
If I had a bajillion monies and didn't need to work I would spend my life as a muse for everyone I meet. I want to help everyone find their passions and do cool things. I like to help. I'm not sure what hashtag to use for that.
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...
Version 0.5.0 of #LogTape, the zero-dependency #logging library for #Deno, #Node.js, #Bun, edge functions, and browsers, has been released! The main additions include:
• Contexts • ANSI color formatter • Comprehensive docs • A few API conveniences
It’s been years since I’ve used NodeJS and was curious about the current situation. Is Deno a thing? I see they backtracked a bit and now have an NPM compatibility layer (although I don’t mind that). And I think I like the direction with JSR.io. Is Bun alright? I’ve seen some comments saying that it was not ready for v1 yet. Is this going to be like an io.js situation and we will all go back to Node eventually?
Hosting on Deno Deploy just got more performant with beta Web Cache API support: 🚀 sub-millisecond read latency 🚅 multi Gbps write throughput 💾 unbounded storage
Deno 1.46 is not only the last 1.x release, but also one of the biggest: - Simpler CLI - Multi-threaded web servers - HTML, CSS, YAML support in `deno fmt` - Better Node/npm compat (support for playwright, google-cloud, etc.) and much more 👇️
The `datetime` attribute of the #HTML `<time>` may seem complicated: it accepts a lot of formats in order to deal with 1) moments 2) durations 3) timezone offsets.
I've rewritten #Fedify several times and in several languages. The first time it was written in #TypeScript, then #Python, then C#, then back to TypeScript. (It was codenamed FediKit at the time of development.) I settled on TypeScript for the following reasons:
• It has a decent JSON-LD implementation. • Lots of people use it. (I wanted Fedify to be widely used.) • It's type-safe enough.
Even if I were to build Fedify again, I would choose TypeScript.
In the next version of #LogTape, a zero-dependency #logging library for #JavaScript & #TypeScript, contexts will be introduced that allow the same set of properties to be shared across multiple log messages. Thanks to @okikio for collaborating on the design! This feature is available for preview in 0.5.0-dev.60+f819929c.
ALT text detailsconst logger = getLogger(["my-app", "my-module"]);
const ctx = logger.with({ userId: 1234, requestId: "abc" });
ctx.info `This log message will have the context (userId & requestId).`;
ctx.warn("Context can be used inside message template: {userId}, {requestId}.");
- Fixed a bug when viewing threads in notification screen. - Implemented setting for CW toots (default collapsed or visible) - Fixed dates - Fixed image viewing - Added help to toot editor - Changed some colors - Updated #curl to 8.9.1 - Added ALT text for image uploads
#LogTape is a logging library for #JavaScript and #TypeScript. It provides a simple and flexible logging system that is easy to use and easy to extend. The highlights of LogTape are:
• Zero dependencies • Designed to be used in libraries as well as apps • Supports virtually every runtime: #Node.js, #Deno, #Bun, edge functions, and browsers • Structured logging • Logger categories (names) are hierarchical • Dead simple sink (destination) interface
This is my 13 year old Acer Aspire One 722-C62kk running the #Linux version of #DOStodon on a current Arch install. I recently learned I can get a new battery for 20€ to revive it. 😊
As of version 4.8 #OsmAnd one can have multiple Quick Action sets. This is great for sorting each item into its own tray. Hopefully in the next versions, one can customize the icons.
ALT text detailsQuick Action tray open within OsmAnd with various German newspaper brands.
On the bottom right are 5 Quick Action buttons: Trees, Newspapers, Hike, City, Notes
Hi I'm Daniel, a 37 year old developer and technical lead at @telemetrydeck ! I enjoy long walks along the #datalake, I work in #analytics and #privacy is super important to me! (Which is why I make an analytics service that provably won't collect personal #data). I also love developing in #swift for #iOS and #vapor and I tolerate #javascript :D~
Ich bin zwar noch bis November ausgebucht, aber wie man so schön sagt: Der frühe Vogel fängt den Wurm, also falls jemand für Nov/Dez/Januar ein Projekt in der Pipeline hat und #PHP#Laravel#Svelte#JavaScript#Vue#Livewire Unterstützung braucht, bitte Bescheid sagen!
#Deno and #Bun people are putting an incredible amount of work modernizing server side js.
The energy is reminding me of early day #Python - so many new tools made with proper care behind rather than most of NodeJS ecosystem which is just glued together with band-aids and staples :blobcatgrimacing:
That being said, after working with Deno for the past week it still feels a bit too bleeding edge though it does work with #jupyter!
## Detail The images depict dots representing positions of tones of the Aeolean mode (relative minor) of a #Major#Scale as appears on a standard #guitar#fretboard
The various SVG's show what is meant to be perceived as "the same mode", with select tones missing. It's a basic, "locate what's missing" #Puzzles
### Deficit
I know how to make the SVG "look how" i want enough to satisfy me. I know what I want for the function of the user interaction.
I don't know efficient JavaScript/ #HTML5 to do it
Any libraries that are meant specifically to assist w/ this type of project? There's jQuery UI for example, but I've never messed with it deeply.
Modern #CATMAID enables hundreds of #neuroscience researchers world wide to collaboratively map neuronal circuits in large datasets, e.g., 100 TB or larger, limited only by bandwidth and server-side storage. The goal: to map and analyse a whole brain #connectome.
Running client-side on #javascript and server-side on #django#python#postgresql, it's a pleasure to use–if I may say so–and easy to hack on to extend its functionality with further widgets.
The first minimally viable product was produced in 2007 by Stephan Saalfeld (what we now refer to, dearly, as "Ice Age CATMAID), who demonstrated to us all that the web, and javascript, where the way to go for distributed, collaborative annotation of large datasets accessed piece-wise. See the original paper: https://academic.oup.com/bioinformatics/article-abstract/25/15/1984/210794
PE argument I find irksome: "everyone has js enabled"
Nobody is saying otherwise.
What we are saying is js fails, often, and interactivity should work *before* JS loads (if it even does). That's progressive enhancement. Or 'islands architecture' if you prefer.
fresh #Introduction time because it's been like 2 years since I wrote one!
I'm erin, a transfeminine front end developer (or to steal from @brad_frost front of the front end developer) living in so called Portland, Oregon. I seem to mostly post about mental health, old thinkpads, craft web development, privacy, security, and the death of the world wide web. I post about politics too (sorry about that!). I have a blog at @erin@blog.kvuzet.org and a I post about books I'm reading on bookwyrm at @kvuzet@wyrmsign.org
ok, time for a big old list of tags that I'll probably update later:
Now that our instance has a higher size limit for toots, time for a re-#introduction. This time with more hashtags!
Hi! I'm Jeff. :blobcatwave:
I've been a software engineer since around 1999 I guess. I started with #WebDev back in the early days of applets, DHTML, and Flash. I've since moved on to #FullStack work on just about anything that has a compiler or an interpreter. I've even recently dabbled in #PCB design and #3DPrinting.
My software specialties are in high performance computing #HPC, #GPGPU, and #ComputationalChemistry. Although I usually enjoy any programming problem with a good challenge to it. I spent waaay too much time in school and got all the degrees in computer science. I still work in #academia part-time writing research software.
My favorite programming languages at the moment are #Rust and #Kotlin. Although, I've spent a lot of time writing #Javascript lately. With the right tooling it's not completely terrible.
#c - what if everything was a pointer #lisp - what if everything was a linked list #haskell - what if everything was a pure function #forth - what if everything was a stack #lua - what if everything was a hash map #erlang - what if everything was immutable #prolog - what if everything was a pattern to match #java - what if everything was a class #rust - what if everything was a memory allocation problem #golang - what if everything != nil #javascript - what if everything was everything
#HowToThing#Epilogue#LongRead: After 66 days of addressing 30 wildly varied use cases and building ~20 new example projects of varying complexity to illustrate how #ThingUmbrella libraries can be used & combined, I'm taking a break to concentrate on other important thi.ngs...
With this overall selection I tried shining a light on common architectural patterns, but also some underexposed, yet interesting niche topics. Since there were many different techniques involved, it's natural not everything resonated with everyone. That's fine! Though, my hope always is that readers take an interest in a wide range of topics, and so many of these new examples were purposefully multi-faceted and hopefully provided insights for at least some parts, plus (in)directly communicated a core essence of the larger project:
Only individual packages (or small clusters) are designed & optimized for a set of particular use cases. At large, though, thi.ng explicitly does NOT offer any such guidance or even opinion. All I can offer are possibilities, nudges and cross-references, how these constructs & techniques can be (and have been) useful and/or the theory underpinning them. For some topics, thi.ng libs provide multiple approaches to achieve certain goals. This again is by design (not lack of it!) and stems from hard-learned experience, showing that many (esp. larger) projects highly benefit from more nuanced (sometimes conflicting approaches) compared to popular defacto "catch-all" framework solutions. To avid users (incl. myself) this approach has become a somewhat unique offering and advantage, yet in itself seems to be the hardest and most confusing aspect of the entire project to communicate to newcomers.
So seeing this list of new projects together, to me really is a celebration (and confirmation/testament) of the overall #BottomUpDesign#ThingUmbrella approach (which I've been building on since ~2006): From the wide spectrum/flexibility of use cases, the expressiveness, concision, the data-first approach, the undogmatic mix of complementary paradigms, the separation of concerns, no hidden magic state, only minimal build tooling requirements (a bundler is optional, but recommended for tree shaking, no more) — these are all aspects I think are key to building better (incl. more maintainable & reason-able) software. IMO they are worth embracing & exposing more people to and this is what I've partially attempted to do with this series of posts...
ICYMI here's a summary of the 10 most recent posts (full list in the https://thi.ng/umbrella readme). Many of those examples have more comments than code...
ALT text detailsCover of the book “Exploring JavaScript (ES2024 edition)” by Axel Rauschmayer. It shows a rhinoceros.
ALT text detailsCover of the book “Deep JavaScript” by Axel Rauschmayer. It shows a freediver who swims under water and follows a rope down into the deep.
ALT text detailsCover of the book “Tackling TypeScript” by Axel Rauschmayer. It shows a a pair of boxing gloves.
ALT text detailsCover of the book “Shell scripting with Node.js” by Axel Rauschmayer. It shows a field of light blue hexagonal bars, with three yellow ones in the middle.
My life’s work is building Oolie, our family business and Certified #BCorp helping families sleep better with #organic bedding and baby products. I hope you’ll check us out.
In my former career, I was into online learning, creative coding, and data visualization, even publishing a couple of books. I still love that stuff (#DataVis#Processing#p5js#d3js#JavaScript), but that feels like 1M years ago.
Expect to see posts about everything mentioned above!
I'm an open-source enthusiast and self-hosting masochist. Initially a #JavaScript developer, still doing all things web, big #WebAssembly fan, recovering conference addict. I am a #DevRel focusing on #DevEx & OSS communities in particular. Also a staunch advocate of flexible, async remote work.
ALT text detailsFlaki sitting on a bench in Tallinn with the coastal Noblessner area in the background. He has a white hoodie, jeans and lace-less black shoes, looking directly into the camera a bit squinty. His right hand is held up to the side, where Lumi the young blue merle collie is lying on the bench, sniffing his palm in search of treats. His left hand is full of colorful dog things, including a fox toy and Lumi's bright blue lead. The rest of the picture has a an overall faded, bluish tint and a white border that makes it almost feel like an album cover.
#LogTape is a logging library for #JavaScript and #TypeScript. It provides a simple and flexible logging system that is easy to use and easy to extend. The highlights of LogTape are:
• Zero dependencies • Designed to be used in libraries as well as apps • Supports virtually every runtime: #Node.js, #Deno, #Bun, edge functions, and browsers • Structured logging • Logger categories (names) are hierarchical • Dead simple sink (destination) interface
Here's my #introductions... I'm into #retrocomputing and #retrocomputers, am a #6502 fan, but I like green spaces and days which not overcast, I like science and #sf - mostly #sfbooks and stories - #computerscience, aka #cs or #compsci, I like #brianeno for his music and his thoughtful writings and funny videos, I write just a little code in #python and #javascript and #assembly and generally spend a lot of time on the internet. Isn't the world a lovely place but in a fine old state though?
#Fedify is an #ActivityPub server framework in #TypeScript & #JavaScript. It aims to eliminate the complexity and redundant boilerplate code when building a federated server app, so that you can focus on your business logic and user experience.
The key features it provides currently are:
• Type-safe objects for Activity Vocabulary (including some vendor-specific extensions) • #WebFinger client and server • HTTP Signatures • Middleware for handling webhooks • #NodeInfo protocol • #Node.js, #Deno, and #Bun support • CLI toolchain for testing and debugging
If you're curious, take a look at the Fedify website! There's comprehensive docs, a demo, a tutorial, example code, and more:
😅 So I did not fully appreciate the power of hashtags on this place when I wrote my #introduction, so I'm giving it a second go.
• I'm a front-end web developer in Spokane, WA. I work for Red Hat on Ansible Controller using #react, #javascript, #typescript. I don't write so much #CSS here as I have at previous gigs, but, I'm okay at that too…
Fedify is an #ActivityPub server framework in #TypeScript & #JavaScript. It aims to eliminate the complexity and redundant boilerplate code when building a federated server app, so that you can focus on your business logic and user experience.
The key features it provides currently are:
Type-safe objects for Activity Vocabulary (including some vendor-specific extensions)
How did we go back to the world of #javascript being an absolute sausage fest - absolute state of this where there are no women in list until #28 (and then only one) - it's almost exclusively white men
ALT text detailsA screenshot of The State of JS 2023 results - absolutely no women on the list "Which individuals do you read, follow, or just want to highlight in the JavaScript community?" Up to 28
Unicopedia Ægypta is a developer-oriented set of #Unicode utilities related to Egyptian hieroglyphs, wrapped into one single app, built with #Electron.
Just finished manually updating in total ~780 code blocks & snippets in over 400 files (readme's & source code), adding import statements of all used functions & updating comments over the past week (in addition to the 1st round last weekend[1])... Would be super great to hear if people find this useful/helpful (other than the two who were proposing it in the survey feedback)... 😉
Over the next months I will do another pass over the readmes to make it easier to auto-extract various code examples[2], to try them out and/or test them... Also going forward, new code examples added to readme's will aim to support this feature, but there's a huge backlog of existing ones too.
Why do I like it? – Feels cleaner (subjective!). – Easier to grow standard library (no global name clashes). – Namespace imports are faster than property access.
@tante Yes! Especially on the point of react being used in areas HTML + JS work fine. In my side projects I’ve practically sworn off React. The more I learn about options prebaked into JavaScript, the less I value frameworks for a majority of apps. I can’t imagine how many web apps can be rebuilt using WebComponents and CustomEvents and simple custom state management library with less complexity. Worst case, just use Lit or Enhance. #JavaScript#React#WebComponents
I guess I should have an #introduction on here as well:
I'm a programmer and #FreeSoftware enthusiast. I've been using #Linux as my main desktop and #Emacs as my... everything... since 2008. I started off with a lot of distro hopping, my journey took me through #Ubuntu, #Fedora, #Zenwalk, #Gentoo, and #Exherbo before settling on #ArchLinux, now with #Guix on top.
I love writing software in #Lisp (either #CommonLisp or #Scheme or any other), but I don't get enough of a chance to. Except #EmacsLisp, basically all my personal projects end up being written in that. Other than that I've enjoyed writing things in #CSharp, #PHP, #Python, #JavaScript, #Ruby, #Groovy, and several other languages.
My main account is @ryuslash, this is my account for experimenting with self-hosting.
I’ve moved recently, time for a (re)introduction — and a heartfelt Thank You! to @ben
I am a writer, copywriter, online editor, and I generally write a lot; I design websites with plain HTML/CSS/JS or using WordPress and other CMS; occasionally I work as a speaker, podcast producer, sound designer — to mention the most important bits.
ich bin umgezogen und erst seit ein paar Stunden hier auf dem neuen Server, deswegen eine kurze Vorstellung — und ein herzliches Dankeschön an @ben
Ich bin Texter und Online-Redakteur, schreibe auch sonst viel; ich gestalte Websites in HTML, mit WordPress oder anderen CMS, arbeite außerdem gelegentlich als Sprecher, Podcast-Produzent, Sounddesigner – um mal die wesentlichen Dinge genannt zu haben.
I am an artist and professor of Creative Technologies at Virginia Tech. In my work, I focus on the ways technologies of visualization and control intersect with and threaten #trans lives.
#Introduction Greetings! I'm a #software developer in the world of #dotnet and #JavaScript. Worth mentioning - a degree in game dev and table tennis coaching credentials.
I won a Hackathon, and once increased sales by 300%. In my timeline, you'll mostly find reflections on programming, as it is my bread and butter, as my odyssey into open-source continues.
Here to exchange ideas, learn, and share wisdom. Open for spirited discussions. Always game for a chat, so feel free to reach out.
Hey Fediverse! I plan to make this profile a notebook of #TIL bits about #webdev, #javascript, #software and #hardware. Probably the odd toot about digital privacy, free speech and computer history. Will try to help the community as best as I can!
#Introduction Hi, I'm Chris! Originally trained as a mathematician, I spent a few years after grad school as an academic nomad. After my physicist wife got a tenure-track position, I had a contingent position at her university for a number of years. When my wife got tenure, I decided to leave academia. After a few years as a SAHD, I'm now trying to retool as a software dev. I'm passionate about #Python and have recently learnt #Rust. I also mess around with #JavaScript.
Je profite de la vague d'arrivage pour faire mon #introduction que je n'ai jamais vraiment faite finalement :)
Je suis dev, principalement web depuis maintenant une douzaine d'années. J'ai commencé avec #PHP et la stack #WAMP comme beaucoup, un petit passage forcé et douloureux par .NET et maintenant principalement du #JavaScript (avec Vue) #NodeJS et un peu de #Mule
Au delà de tout ça, j'aime les jeux vidéos (BotW et TotK sont en haut de ma liste), le #cinéma, la #moto et les bouquins :)
Ahora que parece que la migración a mi instancia se ha completado es el turno de presentarme...
Me gano la vida como programador #Android tanto con #Kotlin como con #Java, aunque también "domino" otros lenguajes como #PHP o #Javascript y me defiendo con #Swift, #C y otros muchos. También me peleo con mi servidor, y poco a poco voy pasándome al #selfhosting.
Me gusta la #música (casi cualquier género), el #cine (sobre todo terror y ciencia-ficción) y las #series (ciencia-ficción mayormente).
I'm also a music nerd and #HotSauce lover and recently got back into the habit of reading #books. #VideoGames are also something that is dear to my heart.
Feel free to reach out if you want to talk about any of these topics. Welcome to the #FediVerse!
Moin, wir sind #neuhier und eine kleine Softwareentwicklungsfirma aus #Flensburg. Unser Schwerpunkt liegt auf Webentwicklung mit #vuejs#javascript#php und vielem mehr. Wir lieben Open Source Technologien und sind auch pro bono aktiv. Mehr Infos auf unserer Website https://54gradsoftware.de/ Die Toots kommen hauptsächlich von @sabrinkmann
I'm an #anime and #videogame nerd that programs mostly in #elixir and #javascript by day. I also like to explore art and stories, so I read, paint #miniatures, and do some creative writing occasionally.
I'm a #buddhist at heart and regularly spend time meditating, even if its not always for long. I tend to look for the middle path.
I have a confirmed autoimmune disorder and may have a hypermobility disorder. I deal with chronic pain and fatigue regularly. Self-diagnosed #autistic.
I'm an at-home #nudist and I don't see or believe nudity to be inherently sexual. I'm also restoring my foreskin, as are so many.
I'm currently rebuilding my personal knowledge system in #org after many years of bullet journaling.
I'm currently playing Project: Gorgon and the Metroid Prime Remaster!
I have interests across lots of subjects, so I'm hoping you'll hear from me often and with some varied content! Some opinions, even, which I can sometimes be bad at providing.
So, I'm working on a thing for #rstats 📦 {leafem}... Add a geojson layer to a leaflet map and then add a layer selection drop-down menu referencing that layer. Let's us color our geometries according to selected features. Saves a lot of space as we only need to add geometries once and then have #JavaScript take care of the coloring. See https://twitter.com/TimSalabim3/status/1629180151224213510 for the journey so far.
Narrat 🐀 has been getting a bit of attention again so here's another intro of the engine. I think most people who might be interested in this don't actually know about it so I'm hoping to reach more people for once.
Narrat is a game engine I created to easily make interactive fiction games (narrative RPGs, visual novels etc) for desktop or browser.
I’ve worked on this game engine for some time, mostly to help friends make their games. It’s been used on a few small games, and some bigger ones in progress.
I'm a Product Designer at Netflix where I've most recently been working on design systems, but I’ve worked on multiple aspects of the service in my nearly 10 years there. I’m both a designer and a developer — I mostly work with #HTML, #CSS, and #JavaScript.
I’m also a husband and a father.
I used to live in The Bay (San Francisco) and now I live in The Land (Cleveland).
I’m a software engineer at GitHub working on the most impressive metered usage billing system around. My favorite dev languages are #ruby and #javascript, but I venture into #go and #php too.
I’m a dad of 2 and disability advocate currently running for election to my local school board.
Thanks to @nova and the #hachyderm crew for running this server. The open source web and ruby community are what drew me into development, so I love how this is run.
From 1 January 2023, I plan to #buildInPublic my experimental web framework. My aim is to have a framework that is suitable for real-time MPA while load instantly without any setup or compilation. I will use #nusa hashtag to post my progress 😊
ALT text detailsfile counter.js
```js
import { current } from "nusa/std"
export default class { // counter.js
accessor count = 0
increment() { this.count++ }
set() {
this.count = +current.event.target.value
}
}
```
ALT text detailsfile index.html
```html
<script src=nusa/render-scope async></script>
<br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br>
<render-scope>
<link href=counter.js>
<!-- only fetch/run counter.js when user scroll until this scope -->
<button :: on:click=increment text:= count>0</button>
<input inputmode="numeric" type=number :: value:=count on:change=set>
</render-scope>
<br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br>
<render-scope>
<link href=count-every-1ls.js>
<!-- only fetch/run count-every-1s.js when in view -->
<!-- previous <render-scope> also get updated-every-1.js -->
automatically increment every 1s until it can be divided by 5
<button :: on:click=increment text:= count>0</button>
<input inputmode="numeric" type=number :: value:=count on:change=set>
when it dividable by 5, click to continue to increment on every 1s
</render-scope>
```
ALT text detailsfile count-every-1s.js
```js
import Counter from "./counter.js"
import { iterate } from "nusa/std"
setInterval(() => { // count-every-1s.js
iterate.for(Counter, (index, { count }) => {
if (!(count[index] % 5)) { iterate.skip(); return }
count[index]++
})
}, 1e3)
export { default } from "./counter.js"
```
ALT text detailsVideo of a mouse cursor moving over links. When hovered, the link’s underline turns into a wave. When the cursor leaves, the wave vibrates as a damped standing wave until it decays back to a flat line.
ALT text detailsGraph of modified damped cosine function y(t) = -e^{-5t}\cos(2\pi 8t) + 1
Hákarl is the name of my musical project - guitar, oud, violin. Sounds like this: https://vimeo.com/394663122
I live in #Brighton (UK, boo). My politics are broadly (left-) anarchist. Trans rights are human rights, Black Lives Matter.
There's a longer story about it but I use 'they' pronouns online - I do identify IRL as cis (boo) but I'd rather people who don't know me didn't identify me with a gender.
Reposting my #introduction after migrating. I’m 54 & live in southeastern Pennsylvania. Had 2 careers, now pondering a third. 12 years in IT then 16 years of tech blogging / podcasting & a 1.5 year stint at Google. Currently blogging about #chromebooks & #chromeOS on my own. Also covering #IoT on the side. Slowly learning #javascript through a formal program… just because! 12 years of battling #depression to make life more interesting. 😉 I enjoy #motorcycles, #LiverpoolFC & all things #Beatles ✌🏻
ALT text detailsKevin Tofel sitting on a 2015 Moto Guzzi V7 Stone motorcycle.
I’m matt and I spend a lot of my time building things that people use on the internet. I’m always down for #Frontend chat on all things #JavaScript, #React, #WebAssembly etc.
I’m part scientist🔭🥼 (in another life), part maker🔩🪛, part runner🏃🏽♀️🏃♂️, part climber🧗🧗♂️… the list goes on.
I’m also super curious about how #ActivityPub works and the #Fediverse, so now that I’ve been afforded some time off I may take a deeper look 👀
#Introduction: I’m Lucas, bi software developer and Wikimedian from Berlin. I like writing tools for #Wikimedia#Toolforge, mainly in #Python, though I’m also working on a #JavaScript library to use the MediaWiki API; on the projects, I’m mainly active on #Wikidata and #WikimediaCommons. I play the #piano and occasionally live-stream that or post recordings. I’m making my way through #Tolkien’s The History of Middle-earth. I speak German, English and some Portuguese. Nice to meet y’all 🙂
Celebrating my past experimental #projects about state machine #DSL that can generate both code and diagram. But alas, I don't have any single project in need that DSL so continuing it is kinda hard. It's written in #Rust but I have 2 other prototype written in #Nim (require compilation) and #Javascript (pure runtime, no compilation).
If anyone want to collaborate or continue the effort, feel free to ask me. I have some stuff in mind about it. https://github.com/DrSensor/scdlang
6 years ago I left my design job to become a tech writer at #DigitalOcean. I mostly tinkered with #Linux and #Perl in art school, so this was probably inevitable.
Hey everyone 👋🏻 I'm a professional web developer and novice iOS developer. I'm into F1, coffee, and falling into deep research holes about mundane things. This place has big 2008 Twitter vibes and I'm here for it. Say hello!
I'm a software developer in the #boston area that's primarily focused on Web Players. Things like Video.js and media-chrome. I'm also focused on #a11y and accessibility of the players, particularly in the realm of captions, as the current editor of WebVTT and a member of the Timed Text Working Group at the W3C. I also enjoy writing #javascript.
I'm an avid reader, though, mostly consume books as audiobooks. There's a lot of #scifi in there, but also Fantasy, and recently I've been trying to alternate non-fiction in there too. I also watch lots of movies and TV. And not to mention manga and anime.
My name is Stephen Bannasch and I think kindness and curiousity are important.
Used Ruby for all sorts of projects since 2008. Also created very high performance JavaScript model-based visualizations. Recently been digging into machine learning ... which seems both fascinating and creepy. Hardware projects over the years involving sensors and microcontrollers, along with digital and analog design.
Bon. J'ai dû remigrer d'instance pour la 2e fois en 10 jours. Donc revoilà mon #introduction.
Je parle peu et repartage pas mal ce qui me semble intéressant / important. 🌌 J'aime découvrir des choses dans tous les pans scientifiques, particulièrement en #linguistique, #astronomie, #sociologie.
💻 Je code des trucs #JavaScript en faisant gaffe à l'accessibilité et je garde un œil sur le #libre et les questions de #privacy. Et je tripatouille #Linux.
What’s up party people. I’m Ryosuke, I work at #PlayStation prototyping new experiences across console, #VR, and more. Before that I ran a #cannabis publication and studio for over 10 years.
My main hobbies are #classicalguitar and the ancient game #go or #baduk -- I'm 1-5k, always looking for people who want to play in person regardless of level!
Hi, I am known as dunkelstern almost everywhere, in real life just call me “jo”.
I am a backend-developer using #python and #javascript by day, but i am living on github by night too and working on one of those unfinished projects there (#rust, #c, python and #cad)
Hi, ich bin fast überall dunkelstern, im echten leben sagen die leute meistens Jo.
Ich arbeite als backend-entwickler mit #python und #javascript, bin aber auch privat auf github zuhause und kippe dort meine drölf millionen unfertige projekte ab (#rust, #c, python und #cad)
Wenn ich nicht an meinem #smarthome bastel dann wahrscheinlich an irgend nem #3d-drucker oder sonstigem #elektronik gebastel.
Am wochenende findet ihr mich im habitat in augsburg, meinem #makerspace