Problemi Critici con la Gestione Tradizionale degli Screenshot:

• Crisi di Accessibilità: Gli screenshot non sono ricercabili per testo, rendendo quasi impossibile trovare soluzioni specifiche.
• Incubo del Controllo di Versione: Nessun tracciamento degli aggiornamenti, portando a implementazioni obsolete in produzione.
• Epidemia di Lavoro Duplicato: I team ricreano soluzioni che esistono già nella raccolta di screenshot di qualcuno.
• Perdita di Contesto: Gli screenshot senza un'annotazione adeguata perdono dettagli essenziali di implementazione.
• Silos di Conoscenza del Team: Le raccolte individuali di screenshot non avvantaggiano il team di sviluppo più ampio.

La Soluzione Strategica: Trasformare gli screenshot in una base di conoscenza pronta per la produzione utilizzando moderni strumenti di estrazione, metodi di organizzazione sistematici e flussi di lavoro di manutenzione automatizzati.

#Strumenti Avanzati di Estrazione e Analisi del Codice

La tecnologia moderna di estrazione del codice si è evoluta oltre il semplice OCR a sistemi di analisi intelligenti che comprendono il contesto di programmazione e forniscono intuizioni attuabili.

#Confronto Completo degli Strumenti

#HoverNotes: Lo Standard Professionale

HoverNotes rappresenta l'evoluzione della gestione del codice dai tutorial, offrendo capacità che gli strumenti tradizionali di screenshot non possono eguagliare:

Funzionalità Avanzate:

• Analisi AI in tempo reale durante i video tutorial elimina la necessità di catturare manualmente gli screenshot.
• Estrazione del codice sensibile al contesto che comprende i pattern e le relazioni di programmazione.
• Evidenziazione automatica della sintassi per oltre 50 linguaggi di programmazione.
• Cattura della documentazione visiva inclusi diagrammi, mockup di UI e illustrazioni di architettura.
• Organizzazione intelligente delle note con metadati ricercabili e riferimenti incrociati.

Integrazione del Flusso di Lavoro Professionale:

HoverNotes Tutorial Workflow:
1. AI watches tutorial alongside you
2. Automatically extracts code with proper formatting
3. Generates contextual explanations and documentation
4. Creates timestamped references for quick navigation
5. Exports to professional knowledge management systems

#Validazione e Miglioramento Avanzato del Codice

Valutazione Automatizzata della Qualità del Codice

Una volta estratto, il codice richiede una validazione sistematica per garantire la prontezza per la produzione:

Validazione di Sintassi e Stile:

• Linter specifici per linguaggio: ESLint per JavaScript, Pylint per Python, RuboCop per Ruby.
• Formattazione automatizzata: Prettier, Black per uno stile di codice coerente.
• Analisi di sicurezza: Bandit per Python, Brakeman per la scansione di sicurezza di Ruby.

Test di Compatibilità dell'Ambiente:

# Automated environment validation script
#!/bin/bash
echo "Validating extracted tutorial code..."

# Check Node.js version compatibility
npx check-node-version --node ">= 16.0.0"

# Validate package dependencies
npm audit --audit-level moderate

# Test code syntax
npm run lint

# Run basic functionality tests
npm test -- --coverage

Validazione di API e Dipendenze:

• Test degli endpoint: Verificare che gli endpoint API siano attivi e rispondano correttamente.
• Validazione dell'autenticazione: Assicurarsi che i token e i metodi di sicurezza siano aggiornati.
• Compatibilità delle versioni: Controllare l'allineamento delle versioni di framework e librerie.
• Baseline delle prestazioni: Stabilire benchmark per i tempi di risposta e l'utilizzo delle risorse.

#Architettura Strategica della Base di Conoscenza

La creazione di una base di conoscenza scalabile e manutenibile richiede una pianificazione architettonica che supporti sia la produttività individuale che la collaborazione del team.

#Framework di Organizzazione Gerarchica

Struttura Centrata sulla Tecnologia:

/knowledge-base/
├── /frontend/
│   ├── /react/
│   │   ├── /authentication/
│   │   ├── /state-management/
│   │   └── /performance/
│   ├── /vue/
│   └── /angular/
├── /backend/
│   ├── /node/
│   ├── /python/
│   └── /go/
├── /devops/
│   ├── /docker/
│   ├── /kubernetes/
│   └── /ci-cd/
└── /database/
    ├── /sql/
    ├── /nosql/
    └── /orm/

Organizzazione per Fase di Implementazione:

/project-phases/
├── /setup-configuration/
├── /development-patterns/
├── /testing-strategies/
├── /deployment-automation/
└── /monitoring-maintenance/

Mappatura Problema-Soluzione:

/troubleshooting/
├── /authentication-errors/
├── /performance-bottlenecks/
├── /deployment-failures/
├── /integration-issues/
└── /security-vulnerabilities/

#Documentazione Guidata dai Metadati

Intestazioni Complete della Documentazione:

---
title: "JWT Authentication Implementation"
source: 
  url: "https://tutorial-platform.com/jwt-auth"
  author: "Expert Developer"
  platform: "YouTube"
created_date: "2024-03-15"
last_verified: "2024-06-18"
technology_stack:
  - react: "18.2.0"
  - express: "4.18.0"
  - jsonwebtoken: "9.0.0"
difficulty_level: "intermediate"
estimated_time: "45 minutes"
dependencies:
  - bcryptjs
  - express-validator
tags:
  - authentication
  - security
  - jwt
  - react-hooks
related_tutorials:
  - oauth-implementation.md
  - user-session-management.md
validation_status: "tested"
team_review: "approved"
---

#Ricerca e Scoperta Avanzate

Sistema di Tagging Intelligente:

• Tag funzionali: autenticazione, validazione, ottimizzazione, debug.
• Tag tecnologici: specifici per framework, specifici per linguaggio, specifici per strumento.
• Tag di complessità: principiante, intermedio, avanzato, esperto.
• Tag di progetto: personale, team, specifico per cliente, open-source.

Reti di Riferimenti Incrociati:

## Related Implementations
- [OAuth Integration](./oauth-setup.md) - Alternative authentication method
- [Session Management](./session-handling.md) - Complementary user state handling
- [Security Best Practices](./security-patterns.md) - Enhanced security measures

## Prerequisites
- [Environment Setup](../setup/dev-environment.md)
- [Express.js Basics](../backend/express-fundamentals.md)

## Next Steps
- [Advanced JWT Features](./jwt-advanced.md)
- [Multi-factor Authentication](./mfa-implementation.md)

#Controllo di Versione di Livello Produzione per la Documentazione

Trattare la documentazione con lo stesso rigore del codice di produzione garantisce affidabilità, collaborazione e miglioramento continuo.

#Infrastruttura di Documentazione Basata su Git

Struttura Avanzata del Repository:

/docs/
├── /tutorials/
│   ├── /frontend/
│   ├── /backend/
│   └── /fullstack/
├── /assets/
│   ├── /images/
│   ├── /diagrams/
│   └── /videos/
├── /templates/
│   ├── tutorial-template.md
│   └── code-snippet-template.md
├── /automation/
│   ├── link-checker.yml
│   ├── content-validator.py
│   └── dependency-updater.js
├── .gitattributes
├── .gitignore
├── CHANGELOG.md
├── CONTRIBUTING.md
└── README.md

Configurazione di Git LFS per Asset Binari:

# .gitattributes
docs/assets/images/*.png filter=lfs diff=lfs merge=lfs -text
docs/assets/images/*.jpg filter=lfs diff=lfs merge=lfs -text
docs/assets/images/*.gif filter=lfs diff=lfs merge=lfs -text
docs/assets/videos/*.mp4 filter=lfs diff=lfs merge=lfs -text
docs/assets/diagrams/*.svg filter=lfs diff=lfs merge=lfs -text

#Pipeline di Garanzia della Qualità Automatizzata

Flusso di Lavoro Completo di Documentazione CI/CD:

name: Documentation Quality Assurance
on:
  pull_request:
    paths: ['docs/**']
  push:
    branches: [main, develop]

jobs:
  markdown-lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Markdown Lint
        uses: nosborn/github-action-markdown-cli@v3.2.0
        with:
          files: 'docs/**/*.md'
          config_file: '.markdownlint.json'

  link-validation:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Check markdown links
        uses: gaurav-nelson/github-action-markdown-link-check@v1
        with:
          use-quiet-mode: 'yes'
          use-verbose-mode: 'yes'

  code-snippet-testing:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'
      - name: Test code snippets
        run: |
          npm install
          npm run test:docs-snippets

  content-freshness:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Check content freshness
        run: python automation/content-validator.py

  accessibility-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Accessibility validation
        run: |
          npm install -g @accessibility/cli
          accessibility-check docs/

Validazione Automatizzata dei Frammenti di Codice:

# automation/snippet-validator.py
import ast
import subprocess
import yaml
from pathlib import Path

def validate_python_snippets(file_path):
    """Validate Python code snippets in markdown files"""
    with open(file_path, 'r') as f:
        content = f.read()
    
    # Extract Python code blocks
    python_blocks = extract_code_blocks(content, 'python')
    
    for block in python_blocks:
        try:
            ast.parse(block)
            print(f"✓ Valid Python syntax in {file_path}")
        except SyntaxError as e:
            print(f"✗ Syntax error in {file_path}: {e}")
            return False
    
    return True

def validate_dependencies(file_path):
    """Check if documented dependencies are current"""
    with open(file_path, 'r') as f:
        frontmatter = yaml.safe_load(f.read().split('---')[1])
    
    if 'technology_stack' in frontmatter:
        for tech, version in frontmatter['technology_stack'].items():
            if not check_version_currency(tech, version):
                print(f"⚠ Outdated dependency: {tech}@{version}")

#Versionamento Semantico per la Documentazione

Gestione delle Release della Documentazione:

{
  "release-please": {
    "packages": {
      "docs": {
        "component": "documentation",
        "release-type": "simple",
        "bump-minor-pre-major": true,
        "changelog-sections": [
          {"type": "feat", "section": "New Tutorials"},
          {"type": "fix", "section": "Content Updates"},
          {"type": "docs", "section": "Documentation Improvements"}
        ]
      }
    }
  }
}

#Manutenzione e Intelligence dei Contenuti Automatizzata

Mantenere l'attualità della documentazione su larga scala richiede un'automazione intelligente che monitora le modifiche, valida i contenuti e fornisce approfondimenti attuabili.

#Integrazione e Monitoraggio della Piattaforma

Monitoraggio Tutorial Multipiattaforma:

Integrazione con YouTube Data API:

# automation/youtube-monitor.py
from googleapiclient.discovery import build
import json
from datetime import datetime, timedelta

class YouTubeTutorialMonitor:
    def __init__(self, api_key):
        self.youtube = build('youtube', 'v3', developerKey=api_key)
        
    def check_channel_updates(self, channel_id, last_check_date):
        """Monitor specific channels for new tutorial content"""
        request = self.youtube.search().list(
            part='snippet',
            channelId=channel_id,
            publishedAfter=last_check_date.isoformat() + 'Z',
            order='date',
            maxResults=50,
            type='video'
        )
        
        response = request.execute()
        new_tutorials = []
        
        for item in response['items']:
            tutorial_info = {
                'title': item['snippet']['title'],
                'url': f"https://youtube.com/watch?v={item['id']['videoId']}",
                'published': item['snippet']['publishedAt'],
                'description': item['snippet']['description']
            }
            new_tutorials.append(tutorial_info)
            
        return new_tutorials
    
    def analyze_content_relevance(self, video_id):
        """Use AI to analyze if tutorial content is relevant to knowledge base"""
        # Integration with content analysis AI
        pass

Monitoraggio API della Piattaforma Corsi:

# automation/course-monitor.py
import requests
from datetime import datetime

class UdemyCourseMonitor:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://www.udemy.com/api-2.0/"
    
    def check_course_updates(self, course_ids):
        """Monitor Udemy courses for content updates"""
        updated_courses = []
        
        for course_id in course_ids:
            response = requests.get(
                f"{self.base_url}courses/{course_id}/",
                headers={'Authorization': f'Bearer {self.api_key}'}
            )
            
            if response.status_code == 200:
                course_data = response.json()
                last_update = course_data.get('last_update_date')
                
                if self.is_recently_updated(last_update):
                    updated_courses.append({
                        'id': course_id,
                        'title': course_data['title'],
                        'last_update': last_update,
                        'url': f"https://udemy.com/course/{course_data['url']}"
                    })
        
        return updated_courses

#Analisi e Manutenzione dei Contenuti basata su AI

Analisi Intelligente della Freschezza dei Contenuti:

# automation/ai-content-analyzer.py
import openai
from pinecone import Pinecone
import numpy as np

class ContentFreshnessAnalyzer:
    def __init__(self, openai_key, pinecone_key):
        self.openai_client = openai.OpenAI(api_key=openai_key)
        self.pinecone = Pinecone(api_key=pinecone_key)
        
    def analyze_documentation_freshness(self, doc_content, technology_stack):
        """Analyze if documentation is current with latest practices"""
        
        # Generate embedding for current content
        content_embedding = self.generate_embedding(doc_content)
        
        # Query latest best practices from knowledge base
        index = self.pinecone.Index('tech-knowledge')
        similar_content = index.query(
            vector=content_embedding,
            filter={'technology': technology_stack},
            top_k=10,
            include_metadata=True
        )
        
        # Analyze freshness score
        freshness_analysis = self.openai_client.chat.completions.create(
            model="gpt-4",
            messages=[
                {
                    "role": "system",
                    "content": "Analyze technical documentation freshness and identify outdated practices."
                },
                {
                    "role": "user", 
                    "content": f"Current documentation: {doc_content}

Latest practices: {similar_content}

Provide freshness score and recommendations."
                }
            ]
        )
        
        return freshness_analysis.choices[0].message.content

Scansione Automatizzata delle Vulnerabilità delle Dipendenze:

# automation/dependency-scanner.yml
name: Documentation Dependency Security Scan
on:
  schedule:
    - cron: '0 2 * * 1'  # Weekly Monday 2 AM
  workflow_dispatch:

jobs:
  scan-dependencies:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Extract dependencies from documentation
        run: |
          python automation/extract-dependencies.py
          
      - name: Security vulnerability scan
        uses: securecodewarrior/github-action-add-sarif@v1
        with:
          sarif-file: 'security-scan-results.sarif'
          
      - name: Create issue for vulnerabilities
        if: failure()
        uses: peter-evans/create-issue-from-file@v4
        with:
          title: 'Documentation Dependencies Security Alert'
          content-filepath: 'vulnerability-report.md'
          labels: 'security,documentation,dependencies'

#Metriche di Performance e Qualità

Dashboard di Analisi della Documentazione:

# metrics/documentation-analytics.py
class DocumentationMetrics:
    def __init__(self):
        self.metrics = {}
    
    def calculate_usage_metrics(self):
        """Calculate documentation usage and effectiveness"""
        return {
            'tutorial_sync_score': self.calculate_sync_score(),
            'search_success_rate': self.calculate_search_success(),
            'code_reuse_percentage': self.calculate_reuse_rate(),
            'team_adoption_rate': self.calculate_adoption(),
            'content_freshness_score': self.calculate_freshness(),
            'duplicate_content_percentage': self.calculate_duplicates()
        }
    
    def generate_quality_report(self):
        """Generate comprehensive quality assessment"""
        metrics = self.calculate_usage_metrics()
        
        report = {
            'overall_score': sum(metrics.values()) / len(metrics),
            'recommendations': self.generate_recommendations(metrics),
            'action_items': self.prioritize_improvements(metrics)
        }
        
        return report

Benchmark di Performance Target:

#Strategia di Implementazione Aziendale

La scalabilità della gestione della conoscenza dei tutorial tra i team di sviluppo richiede una pianificazione strategica, l'integrazione di strumenti e iniziative di adozione culturale.

#Collaborazione del Team e Condivisione della Conoscenza

Architettura Centralizzata di Gestione della Conoscenza:

Enterprise Knowledge Base Structure:
├── /team-shared/
│   ├── /standards-and-conventions/
│   ├── /approved-patterns/
│   └── /architecture-decisions/
├── /project-specific/
│   ├── /client-a/
│   ├── /product-x/
│   └── /internal-tools/
├── /individual-contributions/
│   ├── /developer-notes/
│   └── /learning-paths/
└── /community-curated/
    ├── /best-practices/
    └── /troubleshooting/

Accesso Basato sui Ruoli e Linee Guida per i Contributi:

• Collaboratori: Possono aggiungere e modificare contenuti in aree designate.
• Revisori: Approvano le modifiche e garantiscono gli standard di qualità.
• Manutentori: Gestiscono l'infrastruttura e i sistemi di automazione.
• Consumatori: Accesso in sola lettura con capacità di feedback.

#Integrazione degli Strumenti e Ottimizzazione del Flusso di Lavoro

Integrazione Aziendale di HoverNotes:

// Enterprise HoverNotes integration configuration
const hoverNotesConfig = {
  organization: 'your-enterprise',
  integrations: {
    knowledgeBase: {
      primary: 'confluence',
      secondary: 'notion',
      export_format: 'markdown'
    },
    versionControl: {
      repository: 'gitlab.enterprise.com/docs',
      auto_commit: true,
      review_required: true
    },
    notification: {
      slack_channel: '#dev-knowledge',
      email_digest: 'weekly'
    }
  },
  quality_gates: {
    ai_review: true,
    peer_review: true,
    automated_testing: true
  }
}

Integrazione del Flusso di Lavoro Automatizzato:

# .github/workflows/knowledge-base-update.yml
name: Knowledge Base Auto-Update
on:
  push:
    paths: ['tutorials/**', 'docs/**']

jobs:
  process-tutorial-content:
    runs-on: ubuntu-latest
    steps:
      - name: Process HoverNotes exports
        run: |
          python scripts/process-hovernotes-export.py
          
      - name: Generate team digest
        run: |
          python scripts/generate-weekly-digest.py
          
      - name: Update search index
        run: |
          curl -X POST "https://algolia.com/api/update" 
            -H "Content-Type: application/json" 
            -d @search-index-update.json

#Misurazione del Successo e Miglioramento Continuo

Indicatori Chiave di Performance per la Gestione della Conoscenza Aziendale:

Framework di Miglioramento Continuo:

1. Revisioni Mensili: Raccolta di feedback del team e analisi delle metriche.
2. Valutazioni Trimestrali: Efficacia degli strumenti e ottimizzazione del flusso di lavoro.
3. Aggiornamenti Strategici Annuali: Evoluzione dello stack tecnologico e allineamento degli obiettivi.
4. Formazione Continua: Workshop sulle migliori pratiche e sviluppo delle competenze sugli strumenti.

#Conclusione: Trasformare la Conoscenza dei Tutorial in Vantaggio Competitivo

La trasformazione sistematica di screenshot di tutorial sparsi in un sistema di gestione della conoscenza pronto per la produzione rappresenta un cambiamento fondamentale nel modo in cui i team di sviluppo affrontano l'apprendimento e la conservazione della conoscenza.

Benefici Strategici Raggiunti:

Impatto sul Singolo Sviluppatore:

• Riduzione del 73% del tempo speso a cercare soluzioni già incontrate.
• Miglioramento dell'89% nel riutilizzo del codice e nel riconoscimento dei pattern.
• Implementazione il 40% più rapida di nuove funzionalità utilizzando pattern documentati.
• Diminuzione del 60% del debug ripetuto di problemi simili.

Benefici per il Team e l'Organizzazione:

• Miglioramento del 25% nella velocità di onboarding dei nuovi membri del team.
• Riduzione del 35% del lavoro duplicato tra i team di sviluppo.
• Aumento del 50% nella condivisione della conoscenza e nella collaborazione tra team.
• Aumento del 40% della qualità complessiva del codice attraverso pattern standardizzati.

L'Effetto Composto della Gestione Sistematica della Conoscenza:

Le organizzazioni che implementano sistemi completi di gestione della conoscenza dei tutorial riportano benefici esponenziali nel tempo. I team che utilizzano sistemi di documentazione strutturati vedono un aumento del 40% nel riutilizzo del codice quando il contenuto del tutorial è ben organizzato, secondo una ricerca di Archbee.

Formula per il Successo dell'Implementazione:

1. Selezione di Strumenti Avanzati: HoverNotes per l'estrazione e l'analisi intelligenti.
2. Organizzazione Sistematica: Gerarchia centrata sulla tecnologia con metadati completi.
3. Infrastruttura di Livello Produzione: Controllo di versione basato su Git con garanzia di qualità automatizzata.
4. Automazione Intelligente: Monitoraggio e manutenzione dei contenuti basati su AI.
5. Integrazione Culturale: Iniziative di adozione del team e processi di miglioramento continuo.

Il Vantaggio Strategico:

La differenza tra le organizzazioni di successo e quelle che lottano con la gestione della conoscenza sta nel trattare la documentazione dei tutorial come un asset strategico piuttosto che come un ripensamento. I team che implementano approcci sistematici alla gestione della conoscenza dei tutorial superano costantemente quelli che si affidano a raccolte di screenshot ad-hoc.

Rendere a Prova di Futuro il Vostro Investimento in Conoscenza:

Man mano che la tecnologia AI continua ad evolversi, la base di una conoscenza dei tutorial ben organizzata e mantenuta sistematicamente diventa ancora più preziosa. Le organizzazioni con basi di conoscenza complete saranno meglio posizionate per sfruttare le future capacità dell'AI per un apprendimento migliorato, il riconoscimento dei pattern e la generazione automatizzata di codice.

L'investimento nella gestione sistematica della conoscenza dei tutorial paga dividendi attraverso una migliore produttività degli sviluppatori, una maggiore qualità del codice, un onboarding accelerato del team e vantaggi competitivi sostenuti in un panorama di sviluppo sempre più guidato dalla conoscenza.

#Domande Frequenti

#Come posso convertire in modo efficiente i video tutorial in documentazione ricercabile?

L'approccio più efficiente combina strumenti basati su AI come HoverNotes con un'organizzazione sistematica. HoverNotes estrae automaticamente il codice con la corretta evidenziazione della sintassi, genera spiegazioni contestuali ed esporta in formati professionali. Ciò elimina la trascrizione manuale e garantisce una cattura completa sia dei contenuti visivi che audio.

#Qual è il modo migliore per organizzare i frammenti di codice dei tutorial per la collaborazione del team?

Implementare una struttura gerarchica che combini stack tecnologici, fasi di implementazione e mappatura problema-soluzione. Utilizzare intestazioni di metadati complete con informazioni sulla versione, tracciamento delle dipendenze e riferimenti incrociati. Stabilire un controllo di versione basato su Git con pipeline di garanzia della qualità automatizzate per garantire coerenza e affidabilità.

#Come posso mantenere la documentazione basata sui tutorial attuale e accurata?

Implementare il monitoraggio automatizzato utilizzando le API della piattaforma (YouTube Data API, Udemy Course API) combinato con l'analisi dei contenuti basata su AI. Impostare controlli settimanali per gli aggiornamenti dei tutorial, la scansione delle vulnerabilità delle dipendenze e l'analisi della freschezza dei contenuti. Le metriche target includono un Punteggio di Sincronizzazione Tutorial ≥ 0.95 e una freschezza dei contenuti < 30 giorni.

#Quali strumenti forniscono la massima precisione per l'estrazione del codice dagli screenshot?

HoverNotes è in testa con il 98% di precisione grazie all'analisi video basata su AI, mentre NormCap raggiunge il 96% per l'elaborazione di screenshot in batch. TextSniper raggiunge il 97% di precisione specificamente per gli ambienti macOS. Scegli in base al tuo flusso di lavoro principale: video tutorial (HoverNotes) o screenshot statici (NormCap).

#Come misuro il successo di un sistema di gestione della conoscenza dei tutorial?

Traccia metriche chiave tra cui il tempo per trovare soluzioni (obiettivo < 2 minuti), la percentuale di riutilizzo del codice (> 40%), il tasso di adozione del team (> 75%) e il contenuto duplicato (< 5%). Implementa il tracciamento analitico per i tassi di successo della ricerca e monitora i tassi di successo dell'implementazione attraverso l'analisi delle revisioni del codice. Valutazioni trimestrali regolari garantiscono un miglioramento continuo e l'allineamento degli obiettivi.