So, I'm writing a piece of software (in Go). Specifically, a domain-specific language (DSL) for making 3D models. (Roughly speaking, what I'm going for is that what I'm building is to Blender as OpenSCAD is to FreeCAD. You write code in a language I'm designing and it uses that code to build and spit out, for instance, 3d game assets with textures, normal maps, rigging, animations, etc.)

I intend to publish it under a FOSS license once it reaches roughly an "alpha" stage. (Once it's actually usable to create generate meshes and export them as files of a couple of different popular 3d file formats.)

I intend at some point to support both interpreting and transpilation of my DSL into Go. As in, you can write code and execute it with something like modelgen run program.mg, or you can transpile it into Go and run it with modelgen transpile program.mg program.go ; go run program.go. (Yes, I get this is pretty ridiculously ambitious, but at least it's good to have a star to set my bearing to.) One potential feature of the transpilation approach is that a game developer could write some code in my DSL for generating models on the fly, transpile it to Go, and then build that Go code directly into the binary of a game they write in Go for purposes of generating models on the fly at runtime. (Based on, say, a list of parameters that the game provides at runtime. "The biome here is cold, so let's generate some humanoid figures with lighter skin to soak up limited light and stockier, stubbier purportions who might appear better able to conserve their body heat. And maybe we generate some wolves with really thick fur that blends into the snowy environment well. Oh, but the biome over there is a hot desert, so let's have some humanoid figures with darker skin to better handle harmful solar radiation.") Making that work properly would also involve building somewhere between "a lot of" and "all of" of my DSL's standard library into their application.

As to the license, first off, I think copyleft is a fucking awesome idea and I want to leverage it to make sure that my DSL is never used to subjugate users or developers, and to promote a cooperative means of development. Given that I have such warm fuzzies for copyleft, my main contenders are: AGPLv3, GPLv3, and LGPLv3.

I've heard Stallman talks in which he indicated that the reason the LGPL was developed in the first place was "strategic", which leads me to believe that less stringent copyleft provisions in service to greater adoption can indeed ultimately serve the cause of increasing users' freedom. (Stallman isn't exactly the most "practical" and "flexible" sort of guy in a lot of regards, so for him to recognize this face makes it seem important.) So I suppose one argument for using the LGPL is to allow other developers to publish software using my project in a way that allows them to keep their code proprietary, even if users who receive a copy of their software still have the right to demand a copy of the source code of all components of my DSL's codebase (including any potential changes/improvements to my DSL's codebase) that might have been included.

Does using the GPL or AGPL, however, mean that if they either statically or dynamically link my code into their program, their whole program becomes a derivative work covered by the (A)GPL? And if so, is that a good thing or a bad thing?

I definitely would love to see a future in which some big/popular game includes a good portion of my AGPL software in the server side of their MMO and players who connect to the official servers are able to demand the source code of the entire server codebase, enabling the game to be modified and improved, and enabling continued playability even after the developer of the game has EOL'd it and shut down official servers. Or if I use the GPL and a game company sells a game with a bunch of my code in it, I'd love for users to discover they have the right to the source code of the whole game and not just the part that is from what I wrote. But honestly, I'm not sure if that's quite how it works.

I guess the main argument to prefer AGPL over GPL is just that it afforts users more freedom and more rights to assert their freedoms than the GPL does. But one major downside I can see is that developers may well see that "A" on the front and completely disregard using my code in their code as an option, making their software entirely proprietary.

Beyond that, I don't want to see any future version of my DSL become proprietary. If some day a very small number of people own the copyright on my code and they conspired to change the license to something proprietary (like, say, Redis did for a while), I think that'd be a bit of a travesty. Which is why I intend for the copyright on contributions from others to be owned by the contributors. A diverse mishmash of different copyright owners for different tiny slivers of the codebase makes it somewhere between "a lot harder" and "impossible" to change the license later. And that's a feature, not a bug. (See also "Ulysses pact".) And if I want to make it harder to change the license in the future, that kindof implies that it behooves me to choose the right license now before it's difficult to change my mind later.

So, I'm hoping some folks here have had the same choice to make at some point in the past, or at least have been involved in such decisions in the past, and might have some insight that might help me choose what's best. I do think probably AGPL would best let me sleep at night, but something like LGPL might well in practice much better preserve the freedoms of downstream users in a more concrete way. I'm not sure!

Thanks in advance for any input whatsoever!

Edit: I'm learning a lot about sheep dogs.

The man who brought us Execution in the Kingdom of Nouns has now written the book (literally!) on "vibe coding".

Brothers, sisters, siblings, today we are truly lost.

I'm watching Campaign 4 as it comes out. (I don't have a Beacon subscription, so I'm catching it live on Thursdays. Except it goes later than my bedtime, so I save half of each episode until the following Monday when it releases on YouTube.)

But aside from that, I've watched all of the first campaign (Vox Machina) and I'm nearly done with the second campaign (Mighty Nein). I'm planning to take a little break from binging old Critical Role content and just keep up with Campaign 4. But at some point I do intend to come back to binging old Critical role content.

I have yet to start Campaign 3 (Bells Hells). And I'm faced with a choice. I could grind through 122 episodes of the actual campaign. But they also have the abridged version that I could watch instead. It'd save a lot of time.

But I don't necessarily know how much of value I'd miss by just watching the abridged version.

So what would folks in this community do in my position? Abridged or the full campaign? I know which way I'm leaning currently, but I'm interested to hear people's opinions as well.

No idea what the deal is here.

This is on my slightly modded Creality Ender 3 Pro. (It's got a CR-Touch, better springs, a metal extruder assembly, an upgraded official Ender 3 Pro motherboard with quieter stepper controller capability. Nothing all that invasive.) Identical gcode worked perfectly fine on my Ender 3 V2 Neo. (Which is sufficiently similar that gcode is interchangeable.) I've used that particular roll of filament for other prints before and had no issues. And the same printer has given me no other similar issues with other prints, including prints that were taller than where it failed on these photographed prints.

After the one on the right failed, I assumed it was a clog and did a cold pull. The second print (still on the bed) started out just fine, but started underextruding the same way at almost exactly the same place. I say "almost" because looking closely in person, it does look like the second started underextruding just maybe 3 to 4 layers later than the first.

I suppose it's possible it was a second clog at almost exactly the same place on the second print, but it's pretty coincidental if so. Plus recovering spontaneously on that second print is pretty weird.

I dunno. Just very weird and I'm hoping folks here have an idea what I might look into to find a solution. Thanks in advance!

Also, just a few more images in case it helps:

Update (finally): Thanks to all who commented. I printed it again with different filament and it printed fine. I'll probably give the offending filament a dry, but I probably don't have enough of it to try another print, so I may not get confirmation that was the (only) issue. Anyway, I'm happy it's not some painful configuration thing, though. Thanks again for the input!

Edit: After I posted this, I found out there are serious questions about how true any of this is. See here for more info. But also, self-serving propaganda is pretty strongly on-brand for anything in the "aRtIfIcIaL iNtElLiGeNce"(tm) space.

So, this one's likely pretty niche, but I'm hoping someone here might know the answer.

So, I've gotten genotype data for myself from 23AndMe (don't worry, I made them delete it before the acquisition) and AncestryDNA years ago and I've been looking into things like SNPs and such more recently. I write code for a living, so I can do some cool things with a little code and the raw data that I've gotten to check into what interesting SNPs I might have.

Something I've noticed recently is that for some SNPs, I've got alleles that aren't listed as a possibility anywhere on the internet that I can find.

Just to take a random example, rs3746544, part of the SNAP25 gene. According to SNPedia, the available alleles are A and C with A being the major allele and C being the minor. So what is my genotype for that SNP?

[tootsweet@computer genome_raw_data]$ grep rs3746544 23andme_raw_data.txt ancestrydna_raw_data.txt
23andme_raw_data.txt:rs3746544    20      10287084        TT
ancestrydna_raw_data.txt:rs3746544   20      10287084        T       T
[tootsweet@computer genome_raw_data]$

TT? There's zero mention of "T" being an allele that you can have for rs3746544.

rs3746544 is very much not the only example. Just a few more among many:

• SNPedia says rs807701 has alleles C and T, but I have AA.
• SNPedia says rs25532 has alleles C and T, but I have AG.
• SNPedia says rs6265 has alleles A and G, but I have TT.

I'm hoping some of you folks know enough about genes to know what might be up with these examples. I'm sure it's just simply something I don't yet understand about genetics. Thanks in advance!

Edit: So I had a bit of a brain fart after writing this in a comment:

(Side note: oddly of the 23 "mismatch" examples I mentioned, my genotype doesn’t have a single allele in common with the documented possible alleles for the SNP. For example, I don’t have any AT’s where the documented alleles are AA, AC, and CC. My genes either match the documented alleles or have no alleles in common with the documented genotypes. Which seems even stranger.)

A's match with T's and C's with G's. I'm guessing when I get a "mismatch" like what I'm talking about, what 23andme or AncestryDNA is giving me is the complementary base pairs. So if I see a CT where the documented options are AA, AG, and GG, I should just consider my CT to be equivalent to an AG. (Because the T matches up with an A and the C matches up with a G.)

So I guess that means that sometimes the equiment that 23andme and AncestryDNA use reads the other side of the DNA strand from the one that's documented in the literature. (This only seems to happen in about 16.5% of cases or therebouts -- at least that's what my napkin math indicates. In most cases, what 23andme and AncestryDNA report in the raw data matches and thus must be measuring/reading/reporting the "same side" of the double helix as the literature talks about.)

At least that theory seems consistent with what I'm seeing. If anybody knows better, I definitely would appreciate any further input!

That said, it does seem kindof odd that any time 23andme reads the "other side" of the DNA molecule, so does AncestryDNA and vice versa. That is, there don't seem to be any cases where they disagree on my genotype for a given SNP. At least I haven't seen any examples of that so far. I might have to do some searching now.

Edit 2: I've done a little more googling based on the first edit above and found this page. It seems 23andme always goes off of the so-called "+ strand" of the "Genome Reference Consortium Human Build 37" human reference genome. So maybe the 23 examples I've found so far are cases where at least some of the literature (or at least SNPedia and EUPedia, if not "the literature") is based more off of what the "Genome Reference Consortium Human Build 37" considers the "- strand". So maybe "the literature" (and/or SNPedia/EUPedia) uses a different reference genome? All this is still just a theory, but I definitely know more than I did a few minutes ago.

Edit 3: Some folks are suggesting that 23AndMe and AncestryDNA may just not be accurate. As in, 23AndMe and AncestryDNA may have a very high error rate when reading my genetic data. If that was the case, I wouldn't expect the inaccuracies to "match" between the two raw data files. So, to test that hypothesis out, I wrote a script to check my 23AndMe raw data against my AncestryDNA data to see how often they disagree. The script is quite slow, but at the moment it's checked over 35,000 SNPs that are measured by both services and found 12 that disagree for an error rate of roughly 0.0343%. From another comment, I mentioned the instances I've found make up about 16.5% of the ones I've checked. So it doesn't seem like that accounts for a very large percentage of these. I'm still leaning pretty heavily toward it just being the "other strand" theory. Thanks again for everyone's input!

Publicly-available web applications typically keep an "access log" -- a log of every request made to a website or web application hit by end users including the URL path. This log is usually viewable by developers.

Aside from that, typically web applications are constantly monitored by various monitoring/alerting software like Data Dog, NewRelic, Dynatrace, Pagerduty, etc, which has the ability to constantly monitor things like the error rate and if the end user's error rate sharply increases from 1% to 10%, let's say, it will send a message directly to a developer's phone.

The thing is, the content of the access logs and the alerts generated are things that depend very significantly on end user behavior. You can literally put arbitrary content into a url and that will show up in the access log. Manipulating alerting might be more challenging, but it could be done with a coordinated group of people (a la [LOIC](https://en.wikipedia.org/wiki/Low_Orbit_Ion_Cannon, though it would take a lot less traffic than a DDOS typically would).

Particularly for websites that don't offer any way to contact them, I'll sometimes drop a message to them in a url and refresh a good dozen times or so. Particularly to express displeasure. Just on the hope that someone will run across it in the access log.

• https://example.com/your_website_apparently_just_doesnt_load_at_all_in_chrome
• https://example.com/fuck_your_signup_wall
• https://example.com/I_cant_in_good_conscience_continue_to_utilize_your_service

Stuff like that. It's surprising how often I feel I have a reason to do that.

(And to be fair, the chance someone would happen across it would be pretty seriously low if a) I was just doing this on my own and b) the site got any significant amount of traffic for me to get drowned out in. I tend to take that into account when I'm doing this. Given how much traffic it gets, what time of day it is, how good the IT department is likely to be, etc, how likely is it to be seen?)

But if you can get a bunch of people involved, you can coordinate to hit one particular URL with a message in it and get a lot of 404s that might well end up in reports or alerts.

But why would you want to do this?

• Protest - A clear message to a company or other organization (government agency, whatever) that what they're doing is not ok with the people. Proof that a company has received such a message can also provide ammunition for a movement.
• Alerting employees to the bad actions of their employer.
• Just being helpful - It's entirely possible for some sites that they just don't know that some particular thing may be broken, vulnerable, or otherwise "bad" in a fixable way. And if there's not a better way to contact them, this might be the only real option. While the whole "coordinated effort a la LOIC" thing might not work, if this became a more common practice, it could be of benefit.
• Clandestine communications with employees without bosses finding out.

Good practices:

• For alerts, remember there's a human on the other end of that alert. Don't wake them at 3:00am for your political cause. Ping them at 2:00pm (their timezone.) It's cool if their boss is paying them to deal with that.
• Consider your target. Do the math. Get an idea how likely it is that what you're attempting will accomplish your goal -- get to the right audience or whatever.
• Try to make what you're doing stand-out to who you're attempting to communicate with. Put ASCII art in it. Use all caps. Put in words/phrases they're likely to be grepping for.
• Maybe use an unusual user agent if you want your messages easily grepped for. (Once you've got their curiosity, they might want to see more.)
• Consider anonymizing technologies like VPNs or Tor. Depending on your aims.
• Consider what will end up putting your message in reports to management.

Could this be used for evil? Yeah, probably. Maybe it's already being done?

• Spamming/scamming website owners. (This could get especially annoying on a large, industrial scale.)
• Head hunting/poaching employees.
• Log injection.