urushitan 漆たん

So what you’re saying is that any president would prioritize corporate profit over national security? Agreed, though I’m unsure why you’re defending that course of action. This isn’t some deal that would cripple Nvidia, they are making money hand over fist right now, this is effort by the Chinese government to get access to stronger Nvidia compute hardware to strengthen their AI capability, likely for cyberwarfare

Mainline kernel devs applied the fix upstream on October 5, ten days before the CVE was published

Debian’s kernel team imports entire upstream stable point releases rather than backporting individual CVE patches into heavily patched kernel trees like some of the other distros. Once the fix shipped in the 6.12.113, 6.1.190 and 7.2.10 stable releases, it arrived in Debian unstable/sid as part of a routine version bump

Then a day after the cve was published and marked as 9.8 (16th) Debian also patched the frozen versions like Trixie and bookworm

Oh no! Anyway

lol the balloon is phasing into the chair because it’s the one thing tha ai didn’t get close

Edit: wait sorry, second thing

A ton of government contractors. If you want federal certification and don’t want to run your own datacenter it’s much easier to go with AWS govcloud or azure government

Yeah probably guided by folks like Peter Thiel and

https://en.wikipedia.org/wiki/Dark_Enlightenment

They’re accelerationists who want the collapse of the United States so they can seize power and turn it into a neofuedalist technocratic state where they are kings

Just leaving their bare ass out there with no ssl, smh

“omg it’s sentient”

Yes, sadly. Microsoft made 193 billion dollars in profit in 2025, and has only made $225 billion dollars in profit this year. The investors are basically starving to death

ok a makefile is basically a script runner like this. the c/c++ compiler doesn’t touch the makefile, that’s a separate tool

edit : main.o kbd.o command.o display.o \
       insert.o search.o files.o utils.o
        cc -o edit main.o kbd.o command.o display.o \
                   insert.o search.o files.o utils.o

main.o : main.c defs.h
        cc -c main.c
kbd.o : kbd.c defs.h command.h
        cc -c kbd.c
command.o : command.c defs.h command.h
        cc -c command.c
display.o : display.c defs.h buffer.h
        cc -c display.c
insert.o : insert.c defs.h buffer.h
        cc -c insert.c
search.o : search.c defs.h buffer.h
        cc -c search.c
files.o : files.c defs.h buffer.h command.h
        cc -c files.c
utils.o : utils.c defs.h
        cc -c utils.c
clean :
        rm edit main.o kbd.o command.o display.o \
           insert.o search.o files.o utils.o

for a rust program, you might have a cargo.toml like

[package]
name = "jsontool"
version = "0.1.0"
edition = "2021"

[dependencies]
anyhow = "1"
clap = { version = "4", features = ["derive"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"

[profile.release]
lto = true

and .cargo/config.toml like (for the local distro config, no internet packages)

[source.crates-io]
replace-with = "distro"

[source.distro]
directory = "/usr/share/cargo/registry"   # or: registry = "sparse+https://crates.internal.example/index/"

[net]
offline = true

If you wanted that same functionality from a makefile for rust it would be something like

# Makefile: build jsontool with plain rustc, no cargo.
RUSTC  ?= rustc
REG    := /usr/share/cargo/registry
OUT    := $(abspath build)
HOST   := $(shell $(RUSTC) -vV | sed -n 's/^host: //p')
FLAGS  := -C opt-level=3 --cap-lints=allow -L dependency=$(OUT) --out-dir $(OUT)
ext     = $(foreach c,$(1),--extern $(c)=$(OUT)/lib$(c).rlib)
extpm   = $(foreach c,$(1),--extern $(c)=$(OUT)/lib$(c).so)

# Pinned by hand. Cargo.lock does this for you; here, a distro upgrade
# renames these directories and the build breaks.
UNICODE_IDENT := $(REG)/unicode-ident-1.0.13
PROC_MACRO2   := $(REG)/proc-macro2-1.0.89
QUOTE         := $(REG)/quote-1.0.37
SYN           := $(REG)/syn-2.0.85
SERDE_DERIVE  := $(REG)/serde_derive-1.0.213
# ... ~20 more ...

# ---- 1. Plain library crate ----
# Edition, crate name (hyphens -> underscores), and features all come from
# reading each crate's Cargo.toml yourself.
$(OUT)/libunicode_ident.rlib:
	$(RUSTC) --edition=2018 --crate-type=lib --crate-name unicode_ident \
	    $(FLAGS) $(UNICODE_IDENT)/src/lib.rs

# ---- 2. Crate with a build.rs: compile it, run it with the env vars cargo
#         would set, then scrape its stdout for cfg flags ----
$(OUT)/proc_macro2.cfg:
	mkdir -p $(OUT)/bs-pm2
	$(RUSTC) --edition=2021 --crate-type=bin $(PROC_MACRO2)/build.rs \
	    -o $(OUT)/bs-pm2/build-script
	cd $(PROC_MACRO2) && env OUT_DIR=$(OUT)/bs-pm2 RUSTC=$(RUSTC) \
	    TARGET=$(HOST) HOST=$(HOST) PROFILE=release OPT_LEVEL=3 \
	    CARGO_MANIFEST_DIR=$(PROC_MACRO2) CARGO_PKG_VERSION=1.0.89 \
	    CARGO_FEATURE_DEFAULT=1 CARGO_FEATURE_PROC_MACRO=1 \
	    CARGO_CFG_TARGET_OS=linux CARGO_CFG_TARGET_ARCH=x86_64 \
	    $(OUT)/bs-pm2/build-script \
	  | sed -n 's/^cargo::\?rustc-cfg=\(.*\)/--cfg=\1/p' > $@

$(OUT)/libproc_macro2.rlib: $(OUT)/proc_macro2.cfg $(OUT)/libunicode_ident.rlib
	$(RUSTC) --edition=2021 --crate-type=lib --crate-name proc_macro2 $(FLAGS) \
	    --cfg 'feature="default"' --cfg 'feature="proc-macro"' \
	    $$(cat $<) $(call ext,unicode_ident) $(PROC_MACRO2)/src/lib.rs

# ---- 3. Proc-macro crate: different crate type, must be built for the
#         HOST (matters when cross-compiling), linked as a .so ----
# syn's feature list must be the UNION of what serde_derive AND clap_derive
# need. Cargo computes this (feature unification); here you work it out by hand.
$(OUT)/libserde_derive.so: $(OUT)/libproc_macro2.rlib $(OUT)/libquote.rlib $(OUT)/libsyn.rlib
	$(RUSTC) --edition=2015 --crate-type=proc-macro --crate-name serde_derive \
	    $(FLAGS) --cfg 'feature="default"' \
	    $(call ext,proc_macro2 quote syn) $(SERDE_DERIVE)/src/lib.rs

# ... ~20 more rules like the above (serde, serde_json, anyhow, and
#     clap_* each have their own quirks, and several have build.rs) ...

# ---- Finally, your program ----
# clap's derive expands to env!("CARGO_PKG_VERSION"), so you fake cargo's env.
# Source files are listed by hand (or you wire up --emit=dep-info .d files).
build/jsontool: src/main.rs src/cli.rs src/convert.rs $(ALL_DEPS)
	CARGO_PKG_NAME=jsontool CARGO_PKG_VERSION=0.1.0 \
	$(RUSTC) --edition=2021 --crate-type=bin --crate-name jsontool $(FLAGS) \
	    $(call ext,anyhow clap serde serde_json) src/main.rs

# Still to write: test (rustc --test + every --extern again), doc-tests
# (rustdoc --test), debug vs release flags, clean, install...

So are you proposing GNU style makefiles for rust then? You say not another tool, just use the compiler. Either you type those commands yourself, you type them into a make style build script, or cargo or another tool automates them.

Cargo combines the features of a package manager with a build system. You can just used the build system without touching the package manager, which is what Debian and other distros do. But I mean sure, for C there’s make cmake automake ninja meson so why not make another for rust

yes, but to manually build packages against libraries yourself would be a nightmare of tooling without cargo.

It’s no different than every base-devel and similar package requiring cmake because sure, you could manually run the c/c++ compilers and linkers yourself against every single file, passing in the flags yourself, but that would take an obscene amount of time to manually build and run every compiler command yourself

https://wiki.debian.org/Rust

Debian builds it’s own local cargo registry by default. If your distro provides “pinned versions” like I said, you won’t need rustup, but you’ll still need cargo to do anything beyond a tiny project with no imports, unless you plan on writing async/http/encryption libraries all yourself.

Even then, a lot of email is reputation based on ip blocks. You can have all of those things correct and still be sent to spam if you’re using a cloud provider or the like. If you want to avoid trying to get up reputation up, your best bet is to use a reputable mail sending system like resend or smtp2go

Well, like with everything now, rust is much more than the compiler, and will need the entire toolchain, so you’d want rustup or pinned toolchain packages so you had access to cargo and the full ecosystem.

Better meme: