Web Development

I like the full-stack framework SvelteKit. It inspired me to write something more minimal, even brutalist, based on Preact, a few small focused modules popular in its ecosystem, and Vite.

There's intentionally not much API. Documentation entirely fits in a long but straightforward README. Like the Django tutorial, it guides you through writing an application using all the primary features of the EviKit framework.

I wanted to use standard modern JavaScript as supported by Node.js 24+ directly. With strict JSDoc type annotations. So no separate language server is needed - you can use Emacs, Kate or any other modern editor of your choice that supports typescript-language-server. Linting using ESLint and Prettier also works without extra plugins.

There's neither JSX nor a new templating language to learn. There are JS helpers for creating common elements, e.g. you write p({ class: "nav" }, a({ href: "/" }, "Home")). You use JS map for loops and ternary operator for conditional constructs.

I focused on old-school urlencoded and multipart forms, and the app is rendered on the server, so apps should remain partially accessible even when JS doesn't load. At the same time, an EviKit app is a proper SPA, hydrated with client-side routing (with URLPattern-based server-side counterpart) and conveniently made dynamic with React-style hooks.

I want to ease the writing of bots and interoperability with low-code tools. So apps generate OpenAPI (Swagger) specification for your API.

Input/output validation using Valibot is first-class. Type checking catches if e.g. after an upgrade your API starts returning something different from your declaration. With less need for boilerplate unit tests, you can focus on end-to-end replication of real user scenarios.

Most apps need databases. Why not try the node:sqlite built-in? I made it easy to declare a schema using the same Valibot helpers that I use for API declaration. EviKit keeps the database in a standard location following the XDG specification. You can save file uploads as SQLite blobs.

Translatable strings of your UI can be automatically extracted using GNU Gettext tools, well-known in Django, WordPress and Linux desktop app ecosystems. I recomment the Poedit editor for translating the resulting .po files. Your app is shown in the browser language if there's a matching translation, with English fallbacks.

For styling, I wanted to avoid non-standard hacks that make Node.js "import" CSS, so I recommend going with daisyUI and the now usual Tailwind CSS.

There's a real-world FOSS app using EviKit: Lanquiz, that lets you import Kahoot quizzes and self-host them in LAN from a laptop during blackouts.

Non-goals: cloud deployment (I only target VPS and LAN apps), competition with Pracht scope (I guess there are bugs to fix, but the framework is more or less finished).

Last but not least, no "AI" whatsoever was used for writing the framework. I don't have a hardline stance, it's more that I don't see how it could be useful for this tool. LLMs let people come up with ever mode code and boilerplate, while I want radically less of it. If you'd like to contribute, let's keep it simple and human.

I'm hoping that I can set up a website for a friend and then export it, so they can import it and make their own minor edits to blogs etc. (each of us running Wordpress Studio locally).

The delpoy is just a simply static zip file drag-and-drop to Netlify, so if we can basically pass the Wordpress project back and forth it would be ideal. Is this possible?

TLDR; The title of this post.

Feel free to reach out for clarity instead of reading the code/docs.

I was working on a “react-like syntax for webcomponents”, I wanted to create something robust and flexible for secure data storage and management.

I started off with an approach for asynchronous state management so that components outside the shadow-root could receive updates. (The events are also encrypted to secure against things like browser extensions.)

https://positive-intentions.com/docs/projects/dim/async-state-management

It then made sense to be able to persist that data so it can work between page releoads.

https://positive-intentions.com/docs/projects/dim/bottom-up-storage

The result looks and works like the following when used in a project.

https://positive-intentions.com/docs/projects/dim/encrypted-store

The Dim framework seems like a dead-end. I wanted to try it out on my existing React projects. So I created the equivalent React hooks.

https://positive-intentions.com/docs/projects/dim/use-dim-store-react

I find it to be performant and I want to push the scale of the approach, so I am in the process of testing it out on my projects. A notable use-case there is storing encrypted files at rest.

IMPORTANT: Im not trying to promote “yet another ui framework”, this is an investigation to see what is possible. You should not use this in your own code. It is not reviewed, audited or production-ready. It is not on npm. Shared for testing, feedback and demo purposes only.

The feature ships in Chrome 150, and only behind a flag, while some sub-features ship in Chrome 152. Turn on chrome://flags/#enable-experimental-web-platform-features to try it. It is not Baseline, and you shouldn't ship it to production yet.

The encouraging part is the cross-engine signal. Firefox has given the proposal a positive standards position, and WebKit has signalled support too. It's rare to see all three engines leaning the same way this early, and it's a good sign this lands as a real, interoperable feature rather than a Chrome-only experiment.

Do you think you are being overworked compared to the industry standard (from experience or vibes) ?

What are your responsibilities ?

Do you do application deployments ?

What does the ownership look like in your compan. Do devs own everything and perform all tasks for the application to function? ( server management, server user profile management, application hosting, etc )

Do you work off hours ?

Do you make the industry standard or are you paid less ?

Have you quit any jobs where you knew it was all over ?

Where you were aware you were in a sinking ship ?

I recently just quit and one of my biggest fears prior to quitting is that coworkers (who I knew were looking for other jobs) were going to leave me in the dust trying to fix issues at a scale way beyond our collective pay and skill set.

In this scenario I would have 0 chance of making meaningful changes and handle basic tasks like site reliability or feature releases, just fixing issues with integrators could take 2 devs alone full time.

I'm curious what other people's experiences are when quitting similar jobs, I had another job way long sgo where the project was already almost dead by the time I joined. I made massive changes along with new collegeaues but the technical debt was insurmountable. I left because I found a much better job to the point my manager tried to counter offer me but just couldn't make it work (I wouldn't have stayed even if the offer is better)

While getting quotes for a site recently the question of filesystem came up a lot and I admittedly didn't know much on the subject.

Doing some research the popular choices appear to be either PHP frameworks or less often ASP.NET frameworks.

Among popular PHP frameworks I see Laravel come up a lot, open source is certainly more reliable than something maintained by Google, Facebook, or Amazon but currently the Laravel maintainers are pushing AI really really hard.

So is the only real solution to learn to program with PHP without using any frameworks or libraries? Can anybody who has implemented a secure fileserver for a website tell me how difficult or easy it would be to learn?

The analytics people didn’t even know where these users were coming from. Of course, your javascript-based analytics package doesn’t see the users you are bouncing because of javascript failures.

Latest proposed method since PATCH from 2010, and PRI from 2015?

I’m calling it now, the adoption of AI agents into software development will be one of the most costly mistakes in the field’s history. Agents cannot program, and it’s taking longer and longer to realize that they can’t. They are a highly sophisticated statistical model designed to mimic the distribution of programming. The output is broken, but in a way that’s getting harder and harder to detect. Which is exactly what you’d expect from an increasingly accurate statistical model.