Mentre nella comunità crypto si fa sempre più strada il dibattito sulla potenziale minaccia dei computer quantistici per la sicurezza di Bitcoin, un gruppo di specialisti del progetto Project11 ha deciso di passare dalla teoria alla pratica. Un team di crittografi, sviluppatori di software, fisici ed esperti di intelligenza artificiale hanno annunciato un concorso per testare la resilienza della crittografia di Bitcoin contro futuri attacchi quantistici.

I partecipanti sono invitati a competere per un premio chiamato Premio Q-Day. Andrà al primo team che riuscirà a decifrare una versione semplificata della crittografia di Bitcoin utilizzando un computer quantistico. Il concorso durerà fino al 5 aprile 2026.

Lo scopo della competizione è quello di testare vulnerabilità Crittografia a curva ellittica (ECC), che viene utilizzato per proteggere molti sistemi digitali, compresi i portafogli BTC. Ai partecipanti verrà chiesto di utilizzare l’algoritmo di Shor, che ha dimostrato teoricamente di essere in grado di decifrare l’ECC se viene utilizzato un processore quantistico sufficientemente potente. Tuttavia, invece delle chiavi a 256 bit utilizzate in Bitcoin, i ricercatori hanno proposto un modello più semplice: chiavi con un livello di sicurezza da 1 a 25 bit.

Secondo gli organizzatori, anche decifrare una chiave a 5 bit sarebbe un’impresa ardua. Questo è ovviamente irrilevante rispetto alla reale protezione di BTC, ma con il progresso delle tecnologie quantistiche il livello di minaccia non potrà che aumentare. IN Progetto11 Sottolineano che dobbiamo iniziare a prepararci ora, perché quando i computer quantistici raggiungeranno la potenza necessaria, sarà troppo tardi.

Gli autori del progetto hanno calcolato che oggi sono potenzialmente a rischio più di 6,26 milioni di BTC, ovvero quasi un terzo di tutte le monete in circolazione. Sono considerati vulnerabili anche più di 10 milioni di indirizzi con un saldo diverso da zero, per i quali è già stata divulgata la chiave pubblica. Il fatto è che un indirizzo Bitcoin è un derivato di una chiave pubblica e, se quest’ultima viene rivelata durante le transazioni, i fondi presenti in quell’indirizzo diventano potenziali prede per gli hacker quantistici.

Il progetto ha già pubblicato un database di indirizzi che potrebbero essere a rischio. Il team di Project11 incoraggia gli utenti a non attendere l’era quantistica, ma a trasferire fondi ora verso nuovi indirizzi creati utilizzando portafogli moderni e sicuri.

La cosa principale è evitare di riutilizzare vecchi indirizzi, soprattutto se da essi sono già state effettuate transazioni. Questo passaggio, secondo gli ideatori del progetto, ridurrà significativamente il rischio di perdere fondi quando si verificherà il cosiddetto “Q-Day”.

L'articolo Challenge per gli Hacker Quantistici! In Palio 1BTC per ogni attacco riuscito proviene da il blog della sicurezza informatica.

A rendere la questione piuttosto complicata è il fatto che la terapia familiare è una pratica continuamente in cambiamento, la teoria sistemica applicata alla psicoterapia è da sempre costantemente in cerca di un modo per superarsi. Dalla sua alba questa pratica si è presentata come inquieta e instabile. Diversamente da quanto accade per altri approcci terapeutici, un sistemico che passasse qualche anno su un’isola deserta, al ritorno difficilmente troverebbe tutto come prima.
O almeno è stato così per una fetta importante della sua storia. Questo si deve, credo, a due ragioni soprattutto...

Dal mio blog di psicoterapia:
massimogiuliani.it/blog/2025/0…

Cosa si insegna e, soprattutto, cosa no (nuove note su integrazioni ed eclettismi) - Corpi che parlano, il blog

"La terapia familiare ha senza dubbio cambiato notevolmente le pratiche di salute mentale, ma in qualche modo ha perso per strada gran parte dell'antica eccitazione (...) Che ne è stato di quell'idea straordinariamente nuova, di quell'audace salto

^{massimo giuliani (Corpi che parlano, il blog)}

When is a crystal not a crystal? When it’s a quasi-crystal, a paradoxical form of metal recently found in some 3D printed metal alloys by [A.D. Iams et al] at the American National Institute for Standards and Technology (NIST).

As you might remember from chemistry class, crystals are made up of blocks of atoms (usually called ‘unit cells’) that fit together in perfect repetition — baring dislocations, cracks, impurities, or anything else that might throw off a theoretically perfect crystal structure. There are only so many ways to tessellate atoms in 3D space; 230 of them, to be precise. A quasicrystal isn’t any of them. Rather than repeat endlessly in 3D space, a quasicrystal never repeats perfectly, like a 3D dimensional Penrose tile. The discovery of quasicrystals dates back to the 1980s, and was awarded a noble prize in 2011.
Penrose tiling– the pattern never repeats perfectly. Quasicrystals do this in 3D. (Image by Inductiveload, Public Domain)
Quasicrystals aren’t exactly common in nature, so how does 3D printing come into this? Well, it turns out that, quite accidentally, a particular Aluminum-Zirconium alloy was forming small zones of quasicrystals (the black spots in the image above) when used in powder bed fusion printing. Other high strength-alloys tended to be very prone to cracking, to the point of usability, and this Al-Zr alloy, discovered in 2017, was the first of its class.

You might imagine that the non-regular structure of a quasicrystal wouldn’t propagate cracks as easily as a regular crystal structure, and you would be right! The NIST researchers obviously wanted to investigate why the printable alloy had the properties it does. When their crystallographic analysis showed not only five-fold, but also three-fold and two-fold rotational symmetry when examined from different angles, the researchers realized they had a quasicrystal on their hands. The unit cell is in the form of a 20-sided icosahedron, providing the penrose-style tiling that keeps the alloy from cracking.

You might say the original team that developed the alloy rolled a nat-20 on their crafting skill. Now that we understand why it works, this research opens up the doors for other metallic quasi-crystals to be developed on purpose, in aluminum and perhaps other alloys.

We’ve written about 3D metal printers before, and highlighted a DIY-able plastic SLS kit, but the high-power powder-bed systems needed for aluminum aren’t often found in makerspaces. If you’re building one or know someone who is, be sure to let us know.

hackaday.com/2025/04/18/d20-sh…

This fun PCB from [Nick Brown] features a miniature railroad implemented with 0805-sized LEDs. With an eye towards designing his own fun interactive PCB badge, the Light-Rail began its journey. He thoroughly documented his process, from shunting various late-night ideas together to tracking down discrepancies between the documentation of a part and the received part.

Inspired by our very own Supercon 2022 badge, he wanted to make a fun badge with a heavy focus on the aesthetics of the final design. He also wanted to challenge himself some in this project, so even though there are over 100 LEDs, they are not laid out in a symmetrical or matrix pattern. Instead, it’s an organic, winding railroad with crossings and stations throughout the board. Designed in KiCad the board contains 144 LEDS, 3 seven-segment displays, and over a dozen buttons that all come together in use for the built in game.

The challenges didn’t stop at just the organic layout of all those LEDs. He decided to use Rust for this project, which entailed writing his own driver for the seven-segment displays as well as creating a tone library for the onboard buzzer. As with all projects, unexpected challenges popped up along the way. One issue with how the oscillator was hooked up meant he wasn’t able to use the ATmega32U4, which was the brains of the entire railroad. After some experimenting, he came up with a clever hack: using a pogo pin jig to connect the clock where it needed to go while programming the board.

Be sure to check out all the details of this journey in his build log. If you love interactive badges also check out some of the other creative boards we’ve featured.

hackaday.com/2025/04/18/track-…

Molte persone che si avvicinano al machine learning non hanno un forte background in ingegneria del software, e quando devono lavorare su un prodotto reale, il loro codice può risultare disordinato e difficile da gestire. Per questo motivo, raccomando sempre vivamente di imparare a usare le coding best practices, che ti permetteranno di lavorare senza problemi all’interno di un team e di migliorare il livello del progetto su cui stai lavorando. Oggi voglio parlare dell’inheritance di Python e mostrare alcuni semplici esempi di come utilizzarla nel campo del machine learning.

Nello sviluppo software e in altri ambiti dell’informatica, il technical debt (noto anche come design debt o code debt) rappresenta il costo implicito di future rielaborazioni dovuto a una soluzione che privilegia la rapidità rispetto a un design a lungo termine.

Se sei interessato a saperne di più sui design patterns, potresti trovare utili alcuni dei miei articoli precedenti.

Python Inheritance

L’Inheritance non è solo un concetto di Python, ma un concetto generale nell’Object Oriented Programming. Quindi, in questo tutorial, dovremo lavorare con classei e oggetti, che rappresentano un paradigma di sviluppo non molto utilizzato in Python rispetto ad altri linguaggi come Java.

Nell’OOP, possiamo definire una classe generale che rappresenta qualcosa nel mondo, ad esempio una Persona, che definiamo semplicemente con un nome, un cognome e un’età nel seguente modo.

class Person:
def __init__(self, name, surname, age):
self.name = name
self.surname = surname
self.age = age

def __str__(self):
return f"Name: {self.name}, surname: {self.surname}, age: {self.age}"

def grow(self):
self.age +=1

In questa classe, abbiamo definito un semplice costruttore (init). Poi abbiamo definito il method str, che si occuperà di stampare l’oggetto nel modo che desideriamo. Infine, abbiamo il method grow() per rendere la persona di un anno più vecchia.

Ora possiamo instanziare un oggetto e utilizzare questa classe.

person = Person("Marcello", "Politi", 28)
person.grow()
print(person)

# output wiil be
# Name: Marcello, surname: Politi, age: 29

E se volessimo definire un particolare tipo di persona, ad esempio un operaio? Possiamo fare la stessa cosa di prima, ma aggiungiamo un’altra variabile di input per aggiungere il suo stipendio.

class Worker:
def __init__(self, name, surname, age, salary):
self.name = name
self.surname = surname
self.age = age
self.salary = salary

def __str__(self):
return f"Name: {self.name}, surname: {self.surname}, age: {self.age}, salary: {self.salary}"

def grow(self):
self.age +=1

Tutto qui. Ma è questo il modo migliore per implementarlo? Vedete che la maggior parte del codice del lavoratore è uguale a quello della persona, perché un lavoratore è una persona particolare e condivide molte cose in comune con una persona.

Quello che possiamo fare è dire a Python che il lavoratore deve ereditare tutto da Persona, e poi aggiungere manualmente tutte le cose di cui abbiamo bisogno, che una persona generica non ha.

class Worker(Person):
def __init__(self, name, surname, age, salary):
super().__init__(name, surname, age)
self.salary = salary

def __str__(self):
text = super().__str__()
return text + f",salary: {self.salary}"

Nella classe worker, il costruttore richiama il costruttore della classe person sfruttando la parola chiave super() e poi aggiunge anche la variabile salary.

La stessa cosa avviene quando si definisce il metodo str. Utilizziamo lo stesso testo restituito da Person usando la parola chiave super e aggiungiamo il salario quando stampiamo l’oggetto.

Ereditarietà nel Machine Learning

Non ci sono regole su quando usare l’ereditarietà nell’machine learning . Non so a quale progetto stiate lavorando, né come sia il vostro codice. Voglio solo sottolineare il fatto che dovreste adottare un paradigma OOP nel vostro codice. Tuttavia, vediamo alcuni esempi di utilizzo dell’ereditarietà.

Definire un BaseModel

Sviluppiamo una classe di base per il modello di ML, definita da alcune variabili standard. Questa classe avrà un metodo per caricare i dati, uno per addestrare, un altro per valutare e uno per preelaborare i dati. Tuttavia, ogni modello specifico preelaborerà i dati in modo diverso, quindi le sottoclassi che erediteranno il modello di base dovranno riscrivere il metodo di preelaborazione.
Attenzione, il modello BaseMLModel stesso eredita la classe ABC. Questo è un modo per dire a Python che questa classe è una classe astratta e non deve essere usata, ma è solo un modello per costruire sottoclassi.

Lo stesso vale per il metodo preprocess_train_data, che è contrassegnato come @abstactmethod. Ciò significa che le sottoclassi devono reimplementare questo metodo.

Guardate questo video per saperne di più su classi e metodi astratti:

youtube.com/embed/UDmJGvM-OUw?…

from abc import ABC, abstractmethod
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
import numpy as np

class BaseMLModel(ABC):
def __init__(self, test_size=0.2, random_state=42):
self.model = None # This will be set in subclasses
self.test_size = test_size
self.random_state = random_state
self.X_train = None
self.X_test = None
self.y_train = None
self.y_test = None

def load_data(self, X, y):
self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(
X, y, test_size=self.test_size, random_state=self.random_state
)

@abstractmethod
def preprocess_train_data(self):
"""Each model can define custom preprocessing for training data."""
pass

def train(self):
self.X_train, self.y_train = self.preprocess_train_data()
self.model.fit(self.X_train, self.y_train)

def evaluate(self):
predictions = self.model.predict(self.X_test)
return accuracy_score(self.y_test, predictions)

Vediamo ora come ereditare da questa classe. Per prima cosa, possiamo implementare un LogisticRegressionModel. Che avrà il suo algoritmo di preelaborazione.

class LogisticRegressionModel(BaseMLModel):
def __init__(self, **kwargs):
super().__init__()
self.model = LogisticRegression(**kwargs)

def preprocess_train_data(self):
#Standardize features for Logistic Regression
mean = self.X_train.mean(axis=0)
std = self.X_train.std(axis=0)
X_train_scaled = (self.X_train - mean) / std
return X_train_scaled, self.y_train

Poi possiamo definire tutte le sottoclassi che vogliamo. Qui ne definisco una per una Random Forest.

class RandomForestModel(BaseMLModel):
def __init__(self, n_important_features=2, **kwargs):
super().__init__()
self.model = RandomForestClassifier(**kwargs)
self.n_important_features = n_important_features

def preprocess_train_data(self):
#Select top `n_important_features` features based on variance
feature_variances = np.var(self.X_train, axis=0)
top_features_indices = np.argsort(feature_variances)[-self.n_important_features:]
X_train_selected = self.X_train[:, top_features_indices]
return X_train_selected, self.y_train

Ora usiamo tutto nella funzione main.

if __name__ == "__main__":
# Load dataset
data = load_iris()
X, y = data.data, data.target

# Logistic Regression
log_reg_model = LogisticRegressionModel(max_iter=200)
log_reg_model.load_data(X, y)
log_reg_model.train()
print(f"Logistic Regression Accuracy: {log_reg_model.evaluate()}")

# Random Forest
rf_model = RandomForestModel(n_estimators=100, n_important_features=3)
rf_model.load_data(X, y)
rf_model.train()
print(f"Random Forest Accuracy: {rf_model.evaluate()}")

Conclusioni

Uno dei principali vantaggi dell’ereditarietà di Python nei progetti ML è nella progettazione di codici modulari, mantenibili e scalabili. L’ereditarietà aiuta a evitare codice ridondante, scrivendo la logica comune in una classe base, come BaseMLModel, riducendo quindi la duplicazione del codice. L’inheritance rende anche facile incapsulare comportamenti comuni in una classe base, permettendo alle subclasses di definire dettagli specifici.

Il principale vantaggio, a mio avviso, è che una codebase ben organizzata e orientata agli oggetti consente a più sviluppatori all’interno di un team di lavorare indipendentemente su parti separate. Nel nostro esempio, un ingegnere capo potrebbe definire il modello base, e poi ogni sviluppatore potrebbe concentrarsi su un singolo algoritmo e scrivere la subclass.
Prima di immergerti in design patterns complessi, concentrati sull’utilizzo delle best practices nell’OOP. Farlo ti renderà un programmatore migliore rispetto a molti altri nel campo dell’AI!

L'articolo Inheritance in Python: la chiave per scrivere codice pulito e collaborativo nel Machine Learning proviene da il blog della sicurezza informatica.

Apple ha rilasciato patch di emergenza per correggere due vulnerabilità zero-day. Secondo l’azienda, questi problemi sono stati sfruttati in attacchi mirati ed “estremamente sofisticati” contro i possessori di iPhone.

Le vulnerabilità sono state scoperte in CoreAudio (CVE-2025-31200 , punteggio CVSS 7,5) e RPAC ( CVE-2025-31201, punteggio CVSS 6,8) i quali interessano iOS, macOS, tvOS, iPadOS e visionOS.

“Apple è consapevole che queste problematiche potrebbero essere sfruttate per attacchi altamente sofisticati contro singoli utenti iOS”, ha affermato Apple in un bollettino sulla sicurezza.

La vulnerabilità CVE-2025-31200 in CoreAudio è stata scoperta dai ricercatori Apple e da quelli di Google Threat Analysis. Questo bug può essere sfruttato per eseguire da remoto del codice su un dispositivo elaborando un flusso audio in un file multimediale dannoso e appositamente preparato.

La vulnerabilità CVE-2025-31201 è stata scoperta dagli stessi specialisti Apple. Questo bug in RPAC consente agli aggressori con accesso in lettura/scrittura di aggirare Pointer Authentication (PAC), una funzionalità di sicurezza iOS progettata per proteggere dalle vulnerabilità della memoria.

Finora, Apple non ha divulgato dettagli su come queste vulnerabilità siano state sfruttate negli attacchi o su chi ne siano stati i bersagli. I problemi sono stati risolti in iOS 18.4.1, iPadOS 18.4.1, tvOS 18.4.1, macOS Sequoia 15.4.1 e visionOS 2.4.1 .

Le vulnerabilità interessano sia i modelli più vecchi che quelli più nuovi dei dispositivi Apple:

• iPhone XS e modelli successivi;
• iPad Pro da 13 pollici, iPad Pro da 12,9 pollici (3a generazione e successive), iPad Pro da 11 pollici (1a generazione e successive), iPad Air di 3a generazione e successive, iPad di 7a generazione e successive e iPad mini di 5a generazione e successive;
• macOS Sequoia;
• Apple TV HD e Apple TV 4K (tutti i modelli);
• Apple Vision Pro.

L'articolo Zero-day su iPhone, Mac e iPad: Apple corre ai ripari con patch d’emergenza proviene da il blog della sicurezza informatica.

Microsoft avverte gli utenti che potrebbero riscontrare una schermata blu di errore e un errore SECURE_KERNEL_ERROR dopo l’installazione degli aggiornamenti di Windows di marzo e aprile. I problemi si verificano dopo l’installazione dell’aggiornamento cumulativo di aprile KB5055523 e dell’aggiornamento di anteprima di marzo KB5053656 che ha interessano solo i dispositivi che eseguono Windows 11 24H2. Dopo aver installato questi aggiornamenti e riavviato il PC, gli utenti interessati riscontrano un arresto anomalo.

“Dopo aver installato l’aggiornamento e riavviato il dispositivo, potresti visualizzare una schermata blu con codice di errore 0x18B, che indica SECURE_KERNEL_ERROR”, afferma Microsoft.

Finché non verrà distribuita una correzione per questo bug tramite Windows Update, l’azienda ha temporaneamente affrontato il problema tramite Known Issue Rollback (KIR), una funzionalità che ripristina gli aggiornamenti problematici distribuiti tramite Windows Update.

Questa correzione verrà automaticamente distribuita a tutti i dispositivi domestici, aziendali e non gestiti dall’IT entro 24 ore. Per velocizzare la distribuzione, Microsoft consiglia agli utenti interessati di riavviare i propri dispositivi.

Per risolvere il problema sui dispositivi Windows aziendali gestiti, gli amministratori di Windows 11 24H2 e Windows Server 2025 devono applicare il Criterio di gruppo KIR KB5053656 250412_03103 .

Vale anche la pena notare che all’inizio di questa settimana Microsoft ha rilasciato aggiornamenti di emergenza per Windows che risolvono un problema diverso che riguarda i criteri di controllo dell’accesso locale nei Criteri di gruppo di Active Directory.

Inoltre, l’azienda ha avvisato gli amministratori di un bug che potrebbe causare la mancata disponibilità dei controller di dominio in Windows Server 2025 dopo un riavvio, con conseguenti errori di servizi e applicazioni.

L'articolo Aggiorna e muori: Windows 11 mostra la schermata Blu Della Morte (BSOD) dopo gli update di Aprile proviene da il blog della sicurezza informatica.

[Charmed Labs] are responsible for bringing numerous open-source hardware products to fruition over the years, and their latest device is an adorably small robotic camera platform called Goby, currently crowdfunding for its initial release. Goby has a few really clever design features and delivers a capable (and hackable) platform for under 100 USD.

Goby embraces its small size, delivering what its creators dub “tinypresence” — or the feeling of being there, but on a very small scale. Cardboard courses, LEGO arenas, or even tabletop gaming scenery hits different when experienced from a first-person perspective. Goby is entirely reprogrammable with nothing more than a USB cable and the Arduino IDE, while costing less than most Arduino starter kits.
Recharging happens by driving over the charger, then pivoting down so the connectors (the little blunt vampire fangs under and to each side of the camera) come into contact with the charger.
One of the physical features we really like is the tail-like articulated caster at the rear. Flexing this pivots Goby up or down (and can even flip Goby completely over), allowing one to pan and tilt the view without needing to mount the camera on a gimbal. It also comes into play for recharging; Goby simply moves over the disc-shaped charger and pivots down to make contact.

At Goby‘s heart is an ESP32-S3 and OmniVision OV2640 camera sensor streaming a live video feed (and driving controls) with WebRTC. Fitting the WebRTC stack onto an ESP32 wasn’t easy, but opens up possibilities beyond just media streaming.

Goby is set up to make launching an encrypted connection as easy as sharing a URL or scanning a QR code. The link is negotiated between bot and client with the initial help of an external server, and once a peer-to-peer connection is established, the server’s job is done and it is out of the picture. [Charmed Labs]’s code for this functionality — named BitBang — is in beta and destined for an open release as well. While BitBang is being used here to make it effortless to access Goby remotely, it’s more broadly intended to make web access for any ESP32-based device easier to implement.

As far as tiny remote camera platforms go, it might not be as small as rebuilding a Hot Wheels car into a micro RC platform, but it’s definitely more accessible and probably cheaper, to boot. Check it out at the Kickstarter (see the first link in this post) and watch it in action in the video, embedded just below the page break.

youtube.com/embed/iuJ_9_ITKFs?…

hackaday.com/2025/04/17/tiny-h…

Running a dairy farm used to be a rather hands-on experience, with the farmer required to be around every few hours to milk the cows, feed them, do all the veterinarian tasks that the farmer can do themselves, and so on. The introduction of milking machines in the early 20th century however began a trend of increased automation whereby a single farmer could handle a hundred cows by the end of the century instead of only a couple. In a recent article in IEEE Spectrum covers the continued progress here is covered, including cows milking themselves, on-demand style as shown in the top image.

The article focuses primarily on Dutch company Lely’s recent robots, which range from said self-milking robots to a manure cleaning robot that looks like an oversized Roomba. With how labor-intensive (and low-margin) a dairy farm is, any level of automation that can improve matters will be welcomed, with so far Lely’s robots receiving a mostly positive response. Since cows are pretty smart, they will happily guide themselves to a self-milking robot when they feel that their udders are full enough, which can save the farmer a few hours of work each day, as this robot handles every task, including the cleaning of the udders prior to milking and sanitizing itself prior to inviting the next cow into its loving embrace.

As for the other tasks, speaking as a genuine Dutch dairy farm girl who was born & raised around cattle (and sheep), the idea of e.g. mucking out stables being taken over by robots is something that raises a lot more skepticism. After all, a farmer’s children have to earn their pocket money somehow, which includes mucking, herding, farm maintenance and so on. Unless those robots get really cheap and low maintenance, the idea of fully automated dairy farms may still be a long while off, but reducing the workload and making cows happier are definitely lofty goals.

Top image: The milking robot that can automatically milk a cow without human assistance. (Credit: Lely)

hackaday.com/2025/04/17/rise-o…

No doubt many readers have at times wished to try their hand at blacksmithing, but it’s fair to say that acquiring an anvil represents quite the hurdle. For anyone not knowing where to turn there’s a video from [Black Bear Forge], in which he takes us through a range of budget options.

He starts with a sledgehammer, the simplest anvil of all, which we would agree makes a very accessible means to do simple forge work. He shows us a rail anvil and a couple of broken old anvils, before spending some time on a cheap Vevor anvil and going on to some much nicer more professional ones. It’s probably the Vevor which is the most interesting of the ones on show though, not because it is particularly good but because it’s a chance to see up close one of these very cheap anvils.

Are they worth taking the chance? The one he’s got has plenty of rough parts and casting flaws, an oddly-sited pritchel and a hardy hole that’s too small. These anvils are sometimes referred to as “Anvil shaped objects”, and while this one could make a reasonable starter it’s not difficult to see why it might not be the best purchase. It’s a subject we have touched on before in our blacksmithing series, so we’re particularly interested to see his take on it.

youtube.com/embed/ZJFFCp6-wKs?…

hackaday.com/2025/04/17/a-blac…

pixelfed.social/p/Fotos.photos…

Diego Herculano

2025-04-17 12:55:16

China

@photography@lemmy.ml
#photography #photo #streetphotography #fotografia #China #360Degrees #35mm #art #travel #press #news #photooftheday #mastodon #PortfolioDay #pixelfed #photojournalism #photodocumentary #beach