How do Linux distro’s deal with this? I feel like however that’s done, I’d like node packages to work in a similar way - “package distro’s”. You could have rolling-release, long-term service w/security patches, an application and verification process for being included in a distro, etc.
It wouldn’t eliminate all problems, of course, but could help with several methods of attack, and also help focus communities and reduce duplication of effort.
If I’m okay with the software (not just trying it out) am I missing out by not using dockers?
No, I think in your use case you’re good. A lot of the key features of containers, such as immutability, reproduceability, scaling, portability, etc. don’t really apply to your use case.
If you reach a point where you find you want a stand-alone linux server, or an auto-reconfiguring reverse proxy to map domains to your services, or something like that - then it starts to have some additional benefit and I’d recommend it.
In fact, using native builds of this software on Windows is probably much more performant.
Containers can be based on operating systems that are different to your computer.
Containers utilise the host’s kernel - which is why there needs to be some hoops to run Linux container on Windows (VM/WSL).
That’s one of the most key differences between VMs and containers. VMs virtualise all the hardware, so you can have a totally different guest and host operating systems; whereas because a container is using the host kernel, it must use the same kind of operating system and accesses the host’s hardware through the kernel.
The big advantage of that approach, over VMs, is that containers are much more lightweight and performant because they don’t have a virtual kernel/hardware/etc. I find its best to think of them as a process wrapper, kind of like chroot for a specific application - you’re just giving the application you’re running a box to run in - but the host OS is still doing the heavy lifting.
As always, it depends! I’m a big fan of “the right tool for the job” and I work in many languages/platforms as the need arises.
But for my “default” where I’m building up the largest codebase, I’ve gone for the following:
I was using file merging, but one issue I found was that arrays don’t get merged - and since switching to use Traefik (which is great) there are a lot of arrays in the config! And I’ve since started using labels for my own tooling too.
I was recently helping someone working on a mini-project to do a bit of parsing of docker compose files, when I discovered that the docker compose spec is published as JSON Schema here.
I converted that into TypeScript types using JSON Schema to TypeScript. So I can create docker compose config in code and then just export it as yaml - I have a build/deploy script that does this at the end.
But now the great thing is that I can export/import that config, share it between projects, extend configs, mix-in, and so on. I’ve just started doing it and it’s been really nice so far, when I get a chance and it’s stabilised a bit I’m going to tidy it up and share it. But there’s not much I’ve added beyond the above at the moment (just some bits to mix-in arrays, which was what set me off on this whole thing!)
I just have a static page that I randomly change - you can see mine here. In this case I was testing the idea of having text within an SVG for better scaling from mobile to desktop, and also I’m loving orange and purple at the moment for some reason! Oh, and I was testing automated deployments from CI/CD, so I always use my own base domain with those first tests!
Are there any good alternatives?
We’ve started using Jitsi for video/screen-sharing and that’s going well so far - but it’s based very much around the “corporate meeting” concept, rather than “playing D&D with mates” or “online gaming with people”.
Mumble is decent enough for voice comms, but of course lacks video, which for my friend group is a deal-breaker. While the audio quality is noticably better most of the time, its noise suppression is not as good as Discord. It does have text chat, but lacks the utility of Discord’s chat - which we use in D&D for sharing information, images, note-taking, etc.
Things do game tracking/voice like Steam, Xbox Live, PSN, etc. but then each only supports their own platforms and services - whereas Discord is common to all.
I think what DIscord does well is bring together a few really established, tried and tested technologies, under one roof and integrates them seamlessly. There is definitely value in that, and I would be really interested in an open source/self-hosted equivalent.
My main concerns with Discord are:
“Out of the frying pan, into the fire”
From a personal perspective, I absolutely agree - I only check my email when I’m specifically expecting something, which is rarely. But at work emails are still incredibly important.
Are there any protocols/services designed specifically for one time codes? Receipts? I think something that’s dedicated to those kinds of tasks would be great from an ease-of-use perspective - no more messing about waiting for delivery, searching through hordes of emails, checking spam folder, etc.
Another problem we have is the rise of oauth - the core idea is great, but the reality is that it ties a lot of people to these Big Tech services.
Glad you sorted it though! It’s a nightmare when you get such an opaque error and there’s so many moving parts that could be responsible!
Assume nothing! Test every little assumption and you’ll find the problem. Some things to get you started:
While not a direct solution to your problem, I no longer manually configure my reverse proxies at all now and use auto-configuring ones instead. The nginx-proxy image is great, along with it’s ACME companion image for automatic SSL cert generation with certbot - you’ll be up and running in under 30 mins. I used that for a long time and it was great.
I’ve since moved to using Traefik as it’s more flexible and offers more features, but it’s a bit more involved to configure (simple, but the additional flexibility means everything requires more config).
That way you just bring up your container and the reverse proxy pulls meta-data from it (e.g. host to map/certbot email) and off it goes.
I use it for basic 2D animation - overlays for videos (captions, title sequences, etc.) and animated diagrams - it works really well when you get used to it (mastering the curves editor is essential!). If you’re going to composite what you do onto video outside of Blender (I use Resolve) you need to export as an image sequence in a format that supports transparency (e.g. png).
For more complex 2D work, Marco Bucci has an interesting three-part series here (the third part goes over animation specifically).
Same - for Windows it’s by far and away the best PDF reader for me. It’s shocking how far down the bloat rabbit hole Adobe Reader has gone!
The issues with LLM’s for coding are numerous - they don’t produce good results in my experience, there’s plenty of articles on their flaws.
But… they do highlight something very important that I think we as developers have been guilty of for decades… a large chunk of what we do is busy work; the model definitions, the api to wrap the model, the endpoint to expose the model, the client to connect to the endpoint, the ui that links to the client, the server-side validation, the client-side validation, etc. On and on… so much of it is just busy work. No wonder LLM’s can offer up solutions to these things so easily - we’ve all been re-inventing the wheel over and over and over again.
Busy work is the worst and it played a big part in why I took a decade-long break from professional software development. But now I’m back running my own business and I’m spending significant time reducing busy work - for profit but also for my own personal enjoyment of doing the work.
I have two primary high-level goals:
When you look at projects with these in mind, you realise that so many “fundamentals” of software development are terrible and inherently lead to busy work.
I’ll give a simple example… let’s say I have the following definition for a model of a simple blog:
User:
id: int generate primary-key
name: string
Post:
id: int generate primary-key
user_id: int foreign-key(User.id)
title: string
body: string
Seems fairly straight-forward, we’ve all done this before - it can be in SQL, prisma, etc. But there’s some fundamental flaws right here:
Now this is just a really simple, almost superficial example - but even then it highlights these problems.
So I’m working on a “pattern” to help solve these kinds of problems, but with a reference implementation in TypeScript. Let’s look at the same example above in my reference implementation:
export const user = new Entity({
name: "User",
fields: [
new NameField(),
],
});
export const post = new Entity({
name: "Post",
fields: [
new NameField("title", { maxLength: 100 }),
new TextField("body"),
],
});
export const userPosts = new ContentCreator({
name: "UserPosts",
author: user,
content: post,
});
export const blogSchema = new Schema({
relationships: [
userPosts,
],
});
So there’s several things to note:
There is another layer beyond this, which is where you define an Application which then lets you specify code generation components that to do all the busy work for you, settings like the ID scheme you want to use, etc.
It’s early days, I’m still refining things, and there is a ton of work yet to do - but I am now using it in anger on commercial projects and it’s saving me time - generating types/interfaces/classes, database definitions, api’s, end points, ui components, etc.
But it’s less about this specific implementation and more about the core idea - can we maximise reuse and minimise what we need to define for a given solution?
There’s so many things that come off the back of it - so much config that isn’t reusable (e.g. docker compose files), so many things that can be automatically determined based on data (e.g. database optimisations), so many things that can be abstracted (e.g. deployment/scaling strategies).
So much busy work that needs to be eliminated, allowing us to give LLM’s a run for their money!
I switched to Traefik as it has auto-configuring for containers for effortless deployment to any of your environments (dev, test, staging, production, etc.) either manually or straight from CI/CD.
The way it works is that you put any configuration in your compose file which is then picked-up by Traefik when its deployed - it reads the config, re-configures itself accordingly, and you’re done! So all your reverse-proxy config, cert config, etc. is all with the project so aren’t going to get out-of-sync.
Just keeps things really clean and simple. Plus it’s a great reverse proxy of course with tons of features, nice admin dashboard, logging, etc.