TheLinuxGuy

Sure until you can’t with flatpak. Flatpak does not safeguard against system binaries and there are always risks associated with that.

Honestly I think I am going to move on from Programming.dev, it’s filled with script kiddie like you. Good lord.

Fuck y’all. Good evening.

Not necessarily, you still need backups or snapshots especially on home directory in case software have a nasty bug like deleting your data.

Yup and I am getting sick of hearing this even on Arch Linux. Like, mofo, you could literally run a snapshot or backup before upgrading, don’t blame us if you’re yoloing your god damn computer. Windows have exactly the same problem too and this is why we have backups. Christ.

On my Arch Linux Install, I literally have a Pacman Hook that would forcibly run backup and verify the said backup before doing a system-wide update.

That one was an old documentation that some of the Chinese folks actually document a lot of quirks related to X11 protocol. I paid about $6000 for translator to work on translating that doc to English and I use it to build my own GUI Toolkit on Linux that I still use to this day.

How it really works:

mpf_t temperature;

Oof, sorry. :( I had hoped that they sorted it out by then…

Maybe try installing swiftshader?

Lol, that one way to put it. Basically a language convergence, not a bad thing to be honest.

Yeah, MLIR is more or less an “IR with Dialects”, a lot of IR language spec share a lot in common with one another, so MLIR try to standardize that similarity between IR. Because of that feature, it reduce amount of IR code that developer have to worry about and they can progressively expand the available dialects for MLIR as they develop a compiler like IREE.

Yup, been writing a new shader language to replace GLSL and HLSL for Vulkan Compute purposed, but I eventually switch from SPIR-V IR to MLIR and use IREE Compiler which accepts the MLIR and compile it to any of CUDA, ROCm, SPIR-V and so forth.

One of the biggest plus with MLIR is that you are also future proofing your code, because that code could feasibly be recompiled for new devices like Neural Net accelerator cards, ASIC, FPGA, and so forth.

Very nice, I was basically forking off Python Lark and rewriting it in C language, with some adjustments to Earley Parser in an experiment to parallelize the processing in Vulkan Compute.

I agree on avoiding on the idea of avoiding having to make your own parser generator, this is precisely what I’m doing and it’s hell. I assumed that you probably want to pick up some understanding on how parser differs when it come to writing grammars. As for ease of use and requiring the least understanding, using something like Earley parser is probably the easiest, it would be slower than other parser algorithms, but it could handle ambiguous grammars making it ideal for first timers to learn how to write a programming language.

Yep, and if open source licensing could be revoked on a whim, you can imagine the chaos that ensued. That would be my understanding as well, old version that have MPL license is perfectly fine to fork off, newer version might not be as it is under a different license. One of the reason why I liked Apache License is that it have make it explicitly clear that it’s irrevocable whereas MPL it is operating on an assumption that it’s not revocable. The most fundamental problem with the legal system in USA is that no law is “set in stone” and leaving things to assumption is open to reinterpretation by the judge who may have sided against you. (Hell, Google vs Oracle on Copyrighted API is still on case-to-case basis, so take it as you will.)

Disclaimer: I am not a lawyer. I just share what I learned from Legal Eagle youtube and few other sources.

I definitely recommends that you start learning about the LL(k), LALR, and perhaps even Earley Parser algorithms. I am assuming you have picked up a little bit on LL(1) parser and some basic lexer, so mastering the parser algorithms are basically the next stop for you.

Once you get the grasp of those things, you are well on your way to designing a programming language.

I would spend it on language translation basically, paying someone to translate international documentations on things that aren’t documented in USA no matter where you look.

I think it’s asinine to ask the developer who contribute to your project, literally taking the time of the day writing the code and submit PR to your project, to pay money to you.

I wouldn’t even bother contributing to the project at that point.

See for yourself and you can see this details in the FAQ.

This is not the first time it happens with Dotnet Open Source packages, there are some pretty funky things going on namely:

Imagesharp (They re-license from Apache 2 to something like Community/Commercial licenses and threw a huge fit over it)

Fody (It expects the software contributors of Fody to be a patron.)

Probably this script:

#!/bin/bash

if [ -z "$1" ]
then
        echo "Please provide git repository url as an argument for this script."
        exit 1
fi
regex='(https?|ftp|file)://[-[:alnum:]\+&@#/%?=~_|!:,.;]*[-[:alnum:]\+&@#/%=~_|]'
if [[ $1 =~ $regex ]]
then
basename=$(basename $1)
reponame=${basename%.*}
curl -X 'POST' 'https://localgitea.com/api/v1/repos/migrate?access_token={Access Token Here}' \
  --insecure \
  -H "accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{  "clone_addr": "'"$1"'",  "issues": false,  "labels": false,  "lfs": false,  "mirror": true,  "mirror_interval": "96h0m0s",  "private": false, "repo_name": "'"$reponame"'", "pull_requests": true,  "releases": true, "repo_owner": "githubpublic",  "service": "git",  "wiki": true}'
else
        echo "Invalid URL"
        exit 1
fi

You can adjust it as needed and as for why I have --insecure flag, I have a direct network cable between my PC to the server, so encryption or HTTPS is not needed here. This is probably my favorite command, because I would write above as .sra.sh in home directory and then alias the .bashrc to make a sra command by adding alias sra=/home/{your user account}/.sra.sh in .bashrc and from there, anytime I have an interesting repository that I want to archive, I simply run sra {git url} and that’s it. It also specify the mirror interval manually for 4 days interval rather than every 8 hours that would’ve needlessly spam the git server.

This is something I rely on everyday both as developer and system admin, I would maintain a different supply chain and prevent a supply chain attacks by generating my own package feeds/registry automatically from Gitea/Forgejo.

Edited to Add: I noticed this community is Powershell, here the powershell version of above:

param (
    [Parameter(Mandatory=$true)]
    [string]$gitRepoUrl
)

function Test-Url($url) {
    $regex = "(https?|ftp|file)://[-[:alnum:]\+&@#/%?=~_|!:,.;]*[-[:alnum:]\+&@#/%=~_|]"
    return $url -match $regex
}


$basename = Split-Path $gitRepoUrl -Leaf
$reponame = [System.IO.Path]::GetFileNameWithoutExtension($basename)

$headers = @{
    'accept' = 'application/json'
    'Content-Type' = 'application/json'
}

$body = @{
    'clone_addr' = $gitRepoUrl
    'issues' = $false
    'labels' = $false
    'lfs' = $false
    'mirror' = $true
    'mirror_interval' = '96h0m0s'
    'private' = $false
    'repo_name' = $reponame
    'pull_requests' = $true
    'releases' = $true
    'repo_owner' = 'githubpublic'
    'service' = 'git'
    'wiki' = $true
} | ConvertTo-Json

Invoke-RestMethod -Uri 'https://localgitea.com/api/v1/repos/migrate?access_token={Access Token Here}' -Method POST -Headers $headers -Body $body -SkipCertificateCheck

deleted by creator