Ambiance codant une application de lecture de vitesse avec Python en seulement 15 minutes

Image de l’auteur | Idéogramme

Imaginez ceci: vous avez une idée pour une application de lecture de vitesse. Au lieu de passer des heures à rechercher les modules et les bibliothèques Python à utiliser, le codage des différents composants et les erreurs de syntaxe de débogage, vous décrivez simplement ce que vous voulez en anglais simple. En quelques minutes, vous modifiez les tailles de police et discutez des améliorations de l’expérience utilisateur avec votre partenaire de codage AI.

Il s’agit du «codage de l’ambiance» – une approche collaborative où les instructions en langage naturel aident à accéder aux applications fonctionnelles grâce à une conversation itérative. Il ne s’agit pas de remplacer les compétences de codage traditionnelles, mais d’accélérer le parcours du concept au prototype de travail.

Aujourd’hui, je vous guiderai à travers la façon dont j’ai construit une application de lecture de vitesse RSVP (présentation en série rapide entièrement fonctionnelle en seulement 15 minutes en utilisant Python.

🔗 Lien vers l’application de lecture de vitesse sur github

Passer de l’idée à la mise en œuvre

Disons que vous avez une idée et que vous souhaitez le coder vibe. Si vous utilisez déjà Chatgpt, Claude ou Gemini, vous pouvez continuer à utiliser la même chose. Je vous recommande d’essayer ces invites (ou de meilleures versions de la même chose) pour voir ce que vous pouvez construire.

Étape 1: Décrivez ce que vous voulez construire

Vous pouvez ouvrir avec une demande simple:

« Je voudrais créer une application de lecture de vitesse de ligne de commande à l’aide de Python qui implémente la technique RSVP (Rapid Serial Visual Présentation). L’application doit s’exécuter sur Ubuntu, afficher les mots séquentiellement à des vitesses réglables et inclure des contrôles de base en fonction des entrées du clavier. Pourriez-vous fournir une implémentation propre et bien structurée avec une bonne gestion des erreurs? »

Aucune spécification technique. Aucune exigence détaillée. Juste une intention claire. C’est là que le codage d’ambiance est super cool – vous commencez par le quoipas le comment.

Cela nous donne un bon point de départ. À partir de cette invite initiale, vous devez obtenir une application de lecture de vitesse basée sur un terminal fonctionnel:

class RSVPReader:
    def __init__(self, text, wpm=250, chunk_size=1):
        self.text = text
        self.wpm = wpm
        self.words = self._prepare_text()
        self.current_index = 0
        self.is_paused = False
        self.delay = 60.0 / (wpm * chunk_size)

L’implémentation initiale comprend:

• Traitement de texte: division du contenu en morceaux lisibles
• Contrôle de vitesse: mots configurables par minute
• Contrôles interactifs: pause, curriculum vitae, naviguer, réglage de la vitesse
• Suivi des progrès: rétroaction visuelle avec les barres de progression
• Prise en charge des fichiers: Lire à partir des fichiers texte ou entrée directe

Pour la mise en œuvre complète de la classe, vous pouvez vérifier le rsvp_reader.py déposer.

Étape 2: Améliorer l’expérience utilisateur

Lors de la demande d’améliorations, nous avons utilisé un langage descriptif et orienté vers des objectifs:

« Je voudrais améliorer la présentation visuelle en centrant l’affichage de texte dans la fenêtre du terminal et en augmentant l’accent sur la police pour une meilleure lisibilité. Pourriez-vous modifier le code pour utiliser la zone centrale du terminal plus efficacement tout en maintenant une sortie propre et professionnelle? »

Cela a provoqué une manipulation terminale:

def _get_terminal_size(self):
	"""Get terminal dimensions for responsive layout"""
	try:
    import shutil
    cols, rows = shutil.get_terminal_size()
    return cols, rows
	except OSError:
    	    return 80, 24  # Sensible fallbacks

Maintenant, l’application de lecture de vitesse fonctionne toujours. Cependant, nous pouvons ajouter quelques améliorations finales.

Étape 3: affiner les exigences de l’interface utilisateur au besoin

Notre demande d’itération finale spécifie clairement les exigences:

« Je voudrais affiner la conception de l’interface avec ces exigences spécifiques: 1) Afficher le texte au centre 40% de l’écran du terminal, 2) réduire la vitesse de lecture par défaut pour une meilleure compréhension, 3) créer une interface de contrôle statique qui ne rafraîchit pas, avec uniquement le texte de lecture à jour dynamiquement, 4) maintenir des bordures propres autour de la zone d’affichage active. Pourriez-vous mettre en œuvre ces modifications tout en préservant toutes les fonctionnalités existantes? »

Cela a entraîné le contrôle du terminal suivant:

def _get_display_area(self):
    """Get the 40% center rectangle dimensions"""
    cols, rows = self._get_terminal_size()
    
    display_width = int(cols * 0.4)
    display_height = int(rows * 0.4)
    
    start_col = (cols - display_width) // 2
    start_row = (rows - display_height) // 2
    
    return start_col, start_row, display_width, display_height

def _draw_static_interface(self):
    """Draw the static interface"""
    # Controls stay fixed, only words change

Un aperçu des détails techniques

Nous avons ce qui suit dans l’application RSVP Speed ​​Reading que nous avons construite.

Filation pour les contrôles réactifs

Cette méthode capture la saisie du clavier en temps réel sans interrompre le programme principal en bassant le terminal en mode brut et en utilisant un sondage d’E / S non bloquant:

def _get_keyboard_input(self):
    """Non-blocking keyboard input handler"""
    old_settings = termios.tcgetattr(sys.stdin)
    try:
        tty.setraw(sys.stdin.fileno())
        while self.is_running:
            if select.select((sys.stdin), (), (), 0.1)(0):
                # Handle real-time input without blocking

Positionnement de terminal intelligent

Cette méthode positionne le texte à des coordonnées exactes sur l’écran du terminal à l’aide de séquences d’échappement ANSI, où le code déplace le curseur vers une ligne et une colonne spécifiques avant d’imprimer le mot:

def _display_word(self, word):
    # Use ANSI escape codes for precise positioning
    print(f'33({word_row};{word_start_col}H{large_word}')

Contrôle de vitesse adaptatif

Cela ajuste dynamiquement la vitesse de lecture basée sur la longueur des mots, donnant aux utilisateurs 20% de temps de plus pour les longs mots (8+ caractères) et 20% de temps en moins pour les mots courts (sous 4 caractères) pour optimiser la compréhension:

# Longer words get more display time
word_delay = self.delay
if len(current_word) > 8:
    word_delay *= 1.2
elif len(current_word) < 4:
    word_delay *= 0.8

Alors oui, vous pouvez exécuter l’application et voir par vous-même comment cela fonctionne.

Tout d’abord, vous pouvez le rendre exécutable comme ainsi. Assurez-vous que vous pouvez ajouter la ligne Shebang en haut du script:

$ chmod +x rsvp_reader.py

Vous pouvez l’exécuter comme ça:

$ ./rsvp_reader.py sample.txt

Vous pouvez trouver plus de détails sur le Fichier de réadme.

Conclusion

Notre session de codage d’ambiance produite:

• Une application de lecture de vitesse entièrement fonctionnelle basée sur un terminal dans Python
• Prise en charge des vitesses de lecture variables (50-1000 + WPM)
• Contrôles en temps réel pour la pause, la navigation et le réglage de la vitesse
• Affichage adaptatif qui fonctionne sur n’importe quelle taille de terminal
• Interface propre et sans distraction axée sur la zone centrale de 40%
• Timing de mot intelligent basé sur la longueur et la complexité

En 15 minutes, nous sommes passés d’une idée simple à une application fonctionnelle que quelqu’un peut réellement utiliser.

Prêt à essayer l’ambiance vous codant? Commencez par une idée simple, décrivez-la en anglais simple et voyez où la conversation vous mène. Le code suivra.

Bala Priya C est développeur et écrivain technique d’Inde. Elle aime travailler à l’intersection des mathématiques, de la programmation, de la science des données et de la création de contenu. Ses domaines d’intérêt et d’expertise incluent DevOps, la science des données et le traitement du langage naturel. Elle aime lire, écrire, coder et café! Actuellement, elle travaille sur l’apprentissage et le partage de ses connaissances avec la communauté des développeurs en créant des tutoriels, des guides pratiques, des pièces d’opinion, etc. Bala crée également des aperçus de ressources engageants et des tutoriels de codage.