O que você prefere usar: async/await ou send…

Prefiro usar async/await.

Vantagens:

Legibilidade: O código parece síncrono, o que simplifica bastante a compreensão da lógica, especialmente ao trabalhar com várias operações assíncronas.
Ausência de callback hell: Evita a aninhamento de callbacks, que pode tornar o código difícil de ler e manter.
Manipulação de erros conveniente: Pode usar blocos padrão try...catch para lidar com erros no código assíncrono.
Melhor suporte para ferramentas externas: A depuração e o perfil do código assíncrono com async/await costumam ser mais confortáveis.

O método send (provavelmente referindo-se ao método send do objeto XMLHttpRequest ou <form>) é usado para enviar dados, mas por si só não é um mecanismo para gerenciar a assíncronia. O resultado da requisição usando send geralmente é tratado através de eventos (onload, onerror, etc.), o que leva a uma estrutura de código orientada a callbacks.

Com async/await, a interação com APIs assíncronas como fetch torna-se mais natural.

// Exemplo com async/await
async function fetchData(url) {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`Erro HTTP: ${response.status}`);
    }
    const data = await response.json();
    return data;
  } catch (error) {
    console.error("Erro ao obter dados:", error);
    throw error; // Propagamos o erro para tratamento superior
  }
}

// Uso da função assíncrona
fetchData("https://api.example.com/data")
  .then(data => {
    console.log("Dados recebidos:", data);
  })
  .catch(error => {
    console.error("Erro ao processar dados:", error);
  });

Comparação com XMLHttpRequest e tratamento via eventos:

// Exemplo com XMLHttpRequest e eventos (semelhante ao uso de send)
function fetchDataXHR(url, callback) {
  const xhr = new XMLHttpRequest();
  xhr.open("GET", url, true); // true faz a requisição assíncrona

  xhr.onload = function() {
    if (xhr.status >= 200 && xhr.status < 300) {
      try {
        const data = JSON.parse(xhr.responseText);
        callback(null, data); // Passa os dados ao callback
      } catch (error) {
        callback(error, null); // Erro no parse JSON
      }
    } else {
      callback(new Error(`Erro HTTP: ${xhr.status}`), null); // Erro HTTP
    }
  };

  xhr.onerror = function() {
    callback(new Error("Erro de rede"), null); // Erro de rede
  };

  xhr.send(); // Envia a requisição
}

// Uso com callback
fetchDataXHR("https://api.example.com/data", function(error, data) {
  if (error) {
    console.error("Erro ao obter dados:", error);
  } else {
    console.log("Dados recebidos:", data);
  }
});

Obviamente, a versão com async/await é mais compacta e fácil de ler.

O que você prefere usar: async/await ou send?