Mirko Benedetti Home

Categoria: Tutorial

La sezione Tutorial del mio sito è un punto di riferimento per chi desidera apprendere in modo pratico e guidato. Qui troverai una raccolta di guide semplici e passo-passo che spaziano dagli argomenti più richiesti a quelli meno esplorati, offrendo soluzioni concrete e facilmente applicabili. Ogni Tutorial è pensato per accompagnarti nella comprensione e nell’applicazione di concetti tecnici e non, con un linguaggio chiaro e accessibile. Che tu sia un principiante o un professionista in cerca di approfondimenti, questa sezione è progettata per supportarti nel tuo percorso di apprendimento.

  • Come puoi accordare la tua Chitarra: Guida Completa

    La Musica è una delle passioni più profonde che possano esistere, e imparare a suonare uno strumento come la chitarra apre le porte a un mondo di creatività e emozione.

    Tuttavia, per ottenere il massimo dalla propria chitarra, è fondamentale conoscerne la manutenzione, partendo da elementi essenziali come la sostituzione delle corde e l’accordatura. In questa guida pratica, ti accompagnerò passo passo per cambiare le corde della tua chitarra, insegnandoti le migliori tecniche di accordatura e introducendoti al tuo primo giro armonico.

    Mi chiamo Mirko Benedetti e sono un copywriter e musicista che se ne intende anche un po’ di Informatica e di siti Internet, ecco per voi questo Tutorial.

    Mirko Benedetti, Tutorial completo di Chitarra e MUsica

    Come cambiare le corde alla Chitarra: strumenti e procedura

    Cambiare le corde della chitarra può sembrare complicato, ma con la giusta tecnica diventa un’operazione semplice e fondamentale per mantenere un suono pulito. I principali strumenti di cui avrai bisogno sono:

    • Un set di nuove corde (scegli in base al tipo di chitarra: acustica o elettrica)
    • Un avvolgi corde (opzionale ma utile per risparmiare tempo)
    • Un tronchesino per tagliare l’eccesso delle corde
    • Un panno per pulire la tastiera prima di installare le nuove corde

    Ecco la procedura per sostituire le corde:

    1. Rimuovi le vecchie corde: Allenta le corde e rimuovile con cautela.
    2. Pulisci la tastiera: Approfitta per togliere la polvere e idratare la tastiera con un po’ d’olio specifico.
    3. Installa le nuove corde: Infila la corda nel ponte e nel meccanismo di accordatura, cercando di misurarne la lunghezza.
    4. Taglia l’eccesso: Usa il tronchesino per evitare che le corde si sfilaccino.
    5. Tendi le corde gradualmente: Accordale in modo morbido, senza forzarle troppo, girando nell’opportuno senso le meccaniche.

    Ora la tua chitarra è pronta per essere accordata finemente.

    Tecniche per accordare la Chitarra: metodi semplici ed efficaci

    Dopo aver installato le nuove corde, il passo successivo è accordare la chitarra, affinché suoni perfettamente. Ci sono due metodi principali:

    1. Accordatura con un accordatore
      Il metodo più preciso e veloce per accordare la tua chitarra è con un accordatore elettronico, che indica se la corda è troppo alta o troppo bassa rispetto alla nota corretta.
    2. Accordatura manuale e a orecchio
      Se vuoi sviluppare il tuo orecchio musicale, puoi imparare ad accordare la chitarra manualmente. Un metodo comune è quello dell’accordatura relativa:
    • Suona la quinta corda (LA) e confronta la nota con la sesta corda premendo al quinto tasto.
    • Procedi con lo stesso principio per le altre corde, tranne che per la terza corda (SOL), da premere al quarto tasto, affinando il suono a orecchio.

    La pratica costante ti aiuterà a migliorare la tua capacità di riconoscere le note e ottenere una chitarra perfettamente intonata.

    Il primo accordo e il primo giro armonico sulla Chitarra

    Ora che la tua chitarra è accordata, è il momento di suonare il tuo primo accordo! Un ottimo punto di partenza è il Mi minore (Em), perché è semplice da eseguire:

    • Posiziona il dito indice sul secondo tasto della quinta corda.
    • Posiziona il dito medio sul secondo tasto della quarta corda.
    • Suona tutte le corde, aperte e non aperte: ecco il tuo primo accordo sulla chitarra!

    Un giro armonico iniziale potrebbe essere basato su: Mi minore (Em) – Sol maggiore (G) – Re maggiore (D) – La maggiore (A). Prova a suonarlo lentamente e senti come le armonie si collegano tra loro.

    La Musica è un viaggio, e imparare nuovi accordi e giri armonici ti permetterà di esprimere emozioni e creare pezzi unici.

    L’importanza della gratitudine e il divertimento nella Musica

    Guardando indietro al mio percorso, non posso che ringraziare chi mi ha introdotto alla Musica, dai maestri ai compagni di avventura, ad esempio guarda la mia prima lezione di chitarra.

    Mi ricordo ancora la mia prima interrogazione: non sapevo le note, ma ho battuto il ritmo con determinazione, ottenendo una sufficienza che mi ha motivato a continuare.

    Ecco tre video Tutorial di Massimo Varini su YouTube che potrebbero esserti utili:

    • Come cambiare le corde – Guarda la lezione su come sostituire le corde della chitarra acustica nel suo Nuovo Manuale di Chitarra.
    • Come accordare la chitarra – Scopri il metodo per accordare la chitarra, sia con accordatore che a orecchio, in questa lezione dettagliata.
    • Il primo giro armonico – Impara il tuo primo giro armonico con quattro accordi per iniziare ad accompagnare le canzoni in questo tutorial.

    Se c’è una cosa che ho imparato, è che la Musica deve essere prima di tutto un piacere: che tu suoni la chitarra, il pianoforte o qualsiasi altro strumento, lasciati trasportare dalle emozioni e divertiti nel tuo viaggio musicale!

    Se l’argomento ti interessa e vuoi ampliare la tua conoscenza, sei libero o libera di contattarmi per avere ulteriori dettagli e per discuterne con me, esprimendo le tue idee in merito.

    Ti è piaciuto questo post? Leggi tutto l’articolo con i commenti, commenta e condividi nei tuoi social network preferiti: mi udiranno meglio. Grazie di cuore!

  • Symfony 7 come REST API, il mio Tutorial Completo

    Buongiorno a tutti. Sono Mirko Benedetti, un esperto informatico nonché copywriter e oggi parliamo di Symfony 7 come REST API, in questo completo ed esaustivo Tutorial.

    Mirko Benedetti, Symfony 7 Rest Api Tutorial Completo

    La prima cosa che dovrete fare per completare questo Tutorial sarà quella di installare PHP e MySQL nella vostra piattaforma. Io vi consiglio Linux come piattaforma, in questo caso questo Tutorial è basato su Ubuntu Linux.

    Ecco qualche guida su come installare sia PHP, MySQL che Symfony sulla vostra piattaforma:

    In particolare dovrete installare Composer e la CLI di Symfony, poi dovrete creare il progetto, in questo modo da terminale:

    $ symfony new symfony7_rest_api --version="7.1.*"
$ cd symfony7_rest_api

    Una volta portate a termine queste semplici operazioni, entriamo nel vivo del Tutorial, potrebbe essere necessario installare anche alcuni altri pacchetti come php-mysql, php-xml e unzip prima di procedere, portate a termine questi compiti con lo strumento apt di Ubuntu, coi necessari privilegi.

    Dopo aver installato Symfony, ed essere entrati nella sua root directory, digitiamo i seguenti comandi, per installare il modulo ORM e l’utility maker bundle:

    $ composer require symfony/orm-pack
$ composer require symfony/maker-bundle --dev

    Una volta fatto questo impostiamo la connessione al database, commentando la linea su PostgreSQL, decommentando e modificando in questo modo la linea su MySQL, nel file .env nella root directory del progetto:

    DATABASE_URL="mysql://youruser:yourpassword@127.0.0.1:3306/app?serverVersion=8.0.32&charset=utf8mb4"

    A questo punto siamo in grado di creare il database e la nostra entità con i seguenti comandi, in questo Tutorial creiamo un’entità di nome Article con quattro campi: title, author, body, url.

    $ php bin/console doctrine:database:create
$ php bin/console make:entity

    Ora invece siamo in grado di creare la tabella nel database, con i seguenti comandi:

    $ php bin/console make:migration
$ php bin/console doctrine:migrations:migrate

    Dunque creiamo il nostro controller, il quale andrà poi editato, usiamo questo comando per farlo:

    $ php bin/console make:controller ArticleController

    Adesso andiamo ad editare il controller appena creato, di seguito creeremo le routes per ogni action del controller, in ArticleController.php nella cartella src/Controller/.

    namespace App\Controller;

use App\Repository\ArticleRepository;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\Routing\Attribute\Route;

class ArticleController extends AbstractController
{

    private $articleRepository;

    public function __construct(ArticleRepository $articleRepository)
    {
        $this->articleRepository = $articleRepository;
    }


    #[Route('/article', name: 'add_article')]
    public function add(Request $request): JsonResponse
    {
	$title = $request->query->get('title');
	$author = $request->query->get('author');
	$body = $request->query->get('body');
	$url = $request->query->get('url');

	if (empty($title) || empty($author) || empty($body)) {
		throw new NotFoundHttpException('Expecting mandatory parameters!');
	}

	$this->articleRepository->saveArticle($title, $author, $body, $url);

	return new JsonResponse(['status' => 'Article created!'], Response::HTTP_CREATED);
    }


    #[Route('/article/{id}', name: 'get_article')]
    public function get($id): JsonResponse
    {
        $article = $this->articleRepository->findOneBy(['id' => $id]);

        $data = [
              'title' => $article->getTitle(),
              'author' => $article->getAuthor(),
              'body' => $article->getBody(),
              'url' => $article->getUrl()
        ];

        return new JsonResponse($data, Response::HTTP_OK);

     }


     #[Route('/articles', name: 'get_articles')]
     public function getAll(): JsonResponse
     {
         $articles = $this->articleRepository->findAll();
         $data = [];

         foreach ($articles as $article) {
                $data[] = [
                        'title' => $article->getTitle(),
                        'author' => $article->getAuthor(),
                        'body' => $article->getBody(),
                        'url' => $article->getUrl()
                ];
         }

         return new JsonResponse($data, Response::HTTP_OK);

     }


     #[Route('/article/{id}/params', name: 'update_articles')]
     public function update($id, Request $request): JsonResponse
     {
         $article = $this->articleRepository->findOneBy(['id' => $id]);

         $article->setTitle($request->query->get('title'));
         $article->setAuthor($request->query->get('author'));
         $article->setBody($request->query->get('body'));
         $article->setUrl($request->query->get('url'));

         $updatedArticle = $this->articleRepository->updateArticle($article);

         return new JsonResponse($updatedArticle->toArray(), Response::HTTP_OK);

     }


     #[Route('/article/{id}', name: 'delete_article')]
     public function delete($id): JsonResponse
     {

         $article = $this->articleRepository->findOneBy(['id' => $id]);

         $this->articleRepository->removeArticle($article);

         return new JsonResponse(['status' => 'Article deleted.'], Response::HTTP_NO_CONTENT);

      }

}

    Ecco invece le routes in config/routes.yaml, possiamo editarle ad esempio con l’editor nano di Linux.

    controllers:
    resource:
        path: ../src/Controller/
        namespace: App\Controller
    type: attribute

add_article:
  path: /article
  controller: App\Controller\ArticleController::add
  methods: POST

get_article:
  path: /article/{id}
  controller: App\Controller\ArticleController::get
  methods: GET

get_aricles:
  path: /articles
  controller: App\Controller\ArticleController::getAll
  methods: GET

update_article:
  path: /article/{id}/params
  controller: App\Controller\ArticleController::update
  methods: PUT

delete_article:
  path: /article/{id}
  controller: App\Controller\ArticleController::delete
  methods: DELETE

    Ora andiamo ad editare gli ultimi due files, il primo, Article.php nella cartella src/Entity/.

    namespace App\Entity;

use App\Repository\ArticleRepository;
use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity(repositoryClass: ArticleRepository::class)]
class Article
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    #[ORM\Column(length: 100)]
    private ?string $title = null;

    #[ORM\Column(length: 100)]
    private ?string $author = null;

    #[ORM\Column(length: 255)]
    private ?string $body = null;

    #[ORM\Column(length: 100, nullable: true)]
    private ?string $url = null;

    public function getId(): ?int
    {
        return $this->id;
    }

    public function getTitle(): ?string
    {
        return $this->title;
    }

    public function setTitle(string $title): static
    {
        $this->title = $title;

        return $this;
    }

    public function getAuthor(): ?string
    {
        return $this->author;
    }

    public function setAuthor(string $author): static
    {
        $this->author = $author;

        return $this;
    }

    public function getBody(): ?string
    {
        return $this->body;
    }

    public function setBody(string $body): static
    {
        $this->body = $body;

        return $this;
    }

    public function getUrl(): ?string
    {
        return $this->url;
    }

    public function setUrl(?string $url): static
    {
        $this->url = $url;

        return $this;
    }

    public function toArray()
    {
        return [
              'title' => $this->getTitle(),
              'author' => $this->getAuthor(),
              'body' => $this->getBody(),
              'url' => $this->getUrl()
        ];
    }

}

    In questo caso abbiamo semplicemente aggiunto il metodo toArray(). Il secondo file da editare è questo: ArticleRepository.php nella cartella src/Repository/.

    namespace App\Repository;

use App\Entity\Article;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\Persistence\ManagerRegistry;
use Doctrine\ORM\EntityManagerInterface;

/**
 * @extends ServiceEntityRepository<Article>
 */
class ArticleRepository extends ServiceEntityRepository
{
    private $manager;

    public function __construct(ManagerRegistry $registry, EntityManagerInterface $manager)
    {
        parent::__construct($registry, Article::class);
                $this->manager = $manager;
    }

    public function saveArticle($title, $author, $body, $url)
    {
        $article = new Article();

        $article
            ->setTitle($title)
            ->setAuthor($author)
            ->setBody($body)
            ->setUrl($url);

        $this->manager->persist($article);
        $this->manager->flush();
    }

    public function updateArticle(Article $article): Article
    {
        $this->manager->persist($article);
        $this->manager->flush();

        return $article;
    }

    public function removeArticle(Article $article)
    {
        $this->manager->remove($article);
        $this->manager->flush();
    }

}

    A questo punto il progetto è completo e funzionante, facciamolo partire con il seguente comando:

    $ symfony server:start

    Per testare il funzionamento di ciò che abbiamo creato non dobbiamo fare altro che aprire una nuova tab e usare cURL per raggiungere gli end point:

    $ curl -X POST "http://127.0.0.1:8000/article?title=Titolo%20Articolo&author=Nome%20Autore&body=Testo%20del%20post&url=Url%20del%20sito"
$ curl -X POST "http://127.0.0.1:8000/article?title=Titolo%20Articolo&author=Nome%20Autore&body=Testo%20del%20post&url=Url%20del%20sito"
$ curl -X GET "http://127.0.0.1:8000/articles"
$ curl -X PUT "http://127.0.0.1:8000/article/1/params?title=Titolo%20Articolo&author=Mirko%20Benedetti&body=Testo%20del%20post&url=Url%20del%20sito"
$ curl -X GET "http://127.0.0.1:8000/article/1"
$ curl -X DELETE "http:/127.0.0.1:8000/article/1"
$ curl -X GET "http://127.0.0.1:8000/articles"

    Turorial Completo su Symfony 7 REST API, Conclusioni:

    In questo Tutorial, ho spiegato come installare Symfony, configurare il database e creare endpoint API efficienti. Il mio obiettivo è fornire una guida pratica di partenza per aiutarti a sviluppare API robuste e scalabili.

    Se l’argomento ti interessa e vuoi ampliare la tua conoscenza, sei libero o libera di contattarmi per avere ulteriori dettagli e per discuterne con me, esprimendo le tue idee in merito.

    Ti è piaciuto questo post? Leggi tutto l’articolo con i commenti, commenta e condividi nei tuoi social network preferiti: mi udiranno meglio. Grazie di cuore!

  • La Mia Prima Lezione di Chitarra: Introduzione Teorica

    Oggi voglio condividere con voi la mia passione per la chitarra e discutere insieme su questo fantastico strumento. Iniziamo con la mia prima lezione, esplorando le parti principali di una chitarra acustica ed elettrica, i concetti di armonia, melodia e ritmica, e alcune basi sugli accordi e le scale.

    Ciao a tutti, sono Mirko Benedetti, un esperto informatico nonché appassionato di Musica, chitarra, e ora facciamo una piccola introduzione teorica.

    Mirko Benedetti, La Mia Prima Lezione di Chitarra

    La mia Prima lezione di Chitarra, le parti principali di una Chitarra

    La chitarra acustica ha diverse parti fondamentali. La cassa di risonanza amplifica il suono delle corde. Il manico contiene i tasti che determinano le note. La tastiera è dove premiamo le corde per cambiare le note. Le meccaniche servono per accordare le corde. Il ponte è dove le corde sono ancorate alla cassa.

    La chitarra elettrica ha molte parti simili a quella acustica, ma con alcune differenze. I pickup catturano le vibrazioni delle corde e le trasformano in segnali elettrici. Il corpo è solido e non ha una cassa di risonanza. I controlli di tono e volume permettono di regolare il suono. Il jack di uscita collega la chitarra all’amplificatore.

    La mia Prima Lezione di Chitarra: Armonia, Melodia e Ritmica nella Musica

    L’armonia si crea suonando più note contemporaneamente. Si concretizza attraverso gli accordi. Gli accordi possono essere maggiori, minori, di settima, e molti altri.

    La melodia è una sequenza di note suonate in successione. Gli arpeggi sono un esempio di melodia basata sugli accordi, dove le note dell’accordo vengono suonate una alla volta.

    La ritmica riguarda il tempo e il ritmo delle note. Si concretizza attraverso lo strumming ritmico di accompagnamento, una delle prime cose che un neofita chitarrista impara. Questo consiste nel suonare le corde ad un certo ritmo per accompagnare una canzone.

    La mia Prima Lezione di Chitarra: Accordi Maggiori e Minori

    Gli accordi maggiori e minori sono i blocchi fondamentali della musica. Un accordo maggiore è composto dalla prima, terza maggiore e quinta nota di una scala. Un accordo minore sostituisce la terza maggiore con una terza minore. Questo cambia il suono da gioioso (maggiore) a più triste o malinconico (minore).

    Un intervallo di terza maggiore è la distanza tra due note che contano quattro semitoni. Ad esempio, nella scala di Do maggiore (C), l’intervallo di terza maggiore è tra Do (C) e Mi (E).

    Un intervallo di terza minore è la distanza tra due note che contano tre semitoni. Ad esempio, nella scala di Do minore (C), l’intervallo di terza minore è tra Do (C) e Mi♭ (E♭).

    Alcune delle Scale Musicali

    Scale Naturali

    Le scale naturali includono la scala maggiore e la scala minore naturale. La scala maggiore ha una sequenza di toni e semitoni: T-T-S-T-T-T-S. La scala minore naturale ha: T-S-T-T-S-T-T.

    Scale Armoniche

    La scala minore armonica è simile alla scala minore naturale ma con la settima nota alzata di un semitono. Questo crea una tensione che si risolve sulla tonica.

    Scale Diatoniche

    Le scale diatoniche includono sia la maggiore che le minori. Queste scale usano solo i toni interi e semitoni.

    Scale Pentatoniche

    Le scale pentatoniche hanno cinque note per ottava. La pentatonica maggiore ha: 1, 2, 3, 5, 6. La pentatonica minore ha: 1, b3, 4, 5, b7. Queste scale sono molto usate nel blues e nel rock.

    Scale Modali

    Le scale modali sono variazioni della scala maggiore. Esempi includono il dorico (2, b3, 4, 5, 6, b7), il frigio (1, b2, b3, 4, 5, b6, b7), e il lidio (1, 2, 3, #4, 5, 6, 7).

    Link utili per approfondire la Chitarra

    Per approfondire la chitarra, ecco alcuni link utili:

    In conclusione, spero che questa introduzione vi abbia ispirato a esplorare il meraviglioso mondo della chitarra. Buona pratica e buon divertimento!

    Se l’argomento ti interessa e vuoi ampliare la tua conoscenza, sei libero o libera di contattarmi per avere ulteriori dettagli e per discuterne con me, esprimendo le tue idee in merito.

    Ti è piaciuto questo post? Leggi tutto l’articolo con i commenti, commenta e condividi nei tuoi social network preferiti: mi udiranno meglio. Grazie di cuore!