Quale idioma di programmazione è più facile da usare per gli sviluppatori principianti che scrivono classi di analisi dei file concreti?
Sto sviluppando una libreria open source, che una delle funzionalità principali è quella di analizzare i file di testo e ottenere informazioni strutturate da essi. Tutti i file contengono lo stesso tipo di informazioni, ma possono essere in diversi formati come XML, testo normale (ognuno di essi è strutturato in modo diverso), ecc. Ci sono un insieme comune di pezzi di informazione che è lo stesso in tutti (es. nomi, nomi di tabelle, alcuni numeri di identificazione)
Esistono formati molto simili tra loro, quindi è possibile definire una classe base comune per facilitare l'implementazione concreta del parser di formato. Quindi posso chiaramente definire le classi base come SplittablePlainTextFormat , XMLFormat , SeparateSummaryFormat , ecc. Ognuno di loro suggerisce il tipo di struttura che intendono analizzare. Tutte le classi concrete dovrebbero avere le stesse informazioni, non importa quale.
Per essere utile, questa libreria deve definire almeno 30-40 di questi parser. Un paio di questi sono più importanti di altri (ovviamente i formati più popolari).
Ora la mia domanda è: qual è il miglior idioma di programmazione da scegliere per facilitare lo sviluppo di queste classi concrete? Lasciami spiegare:
Penso che la programmazione imperativa sia facile da seguire anche per i principianti, perché il flusso è fisso, le dichiarazioni arrivano una dopo l'altra. In questo momento, ho questo:
class SplittableBaseFormat:
def parse(self):
"Parses the body of the hand history, but first parse header if not yet parsed."
if not self.header_parsed:
self.parse_header()
self._parse_table()
self._parse_players()
self._parse_button()
self._parse_hero()
self._parse_preflop()
self._parse_street('flop')
self._parse_street('turn')
self._parse_street('river')
self._parse_showdown()
self._parse_pot()
self._parse_board()
self._parse_winners()
self._parse_extra()
self.parsed = True
Quindi il parser concreto deve definire questi metodi in modo che essi desiderino. Facile da seguire, ma richiede più tempo per implementare ogni singolo parser concreto.
Quindi che dire di dichiarativo? In questo caso le classi base (come SplittableFormat e XMLFormat ) farebbero il sollevamento pesante in base alle dichiarazioni di numero di riga / nodo nella classe concreta e le classi concrete non hanno alcun codice, solo numeri di riga e regex, forse altri tipi di regole.
In questo modo:
class SplittableFormat:
def parse_table():
"Parses TABLE_REGEX and get information"
# set attributes here
def parse_players():
"parses PLAYER_REGEX and get information"
# set attributes here
class SpecificFormat1(SplittableFormat):
TABLE_REGEX = re.compile('^(?P<table_name>.*) other info \d* etc')
TABLE_LINE = 1
PLAYER_REGEX = re.compile('^Player \d: (?P<player_name>.*) has (.*) in chips.')
PLAYER_LINE = 16
class SpecificFormat2(SplittableFormat):
TABLE_REGEX = re.compile(r'^Tournament #(\d*) (?P<table_name>.*) other info2 \d* etc')
TABLE_LINE = 2
PLAYER_REGEX = re.compile(r'^Seat \d: (?P<player_name>.*) has a stack of (\d*)')
PLAYER_LINE = 14
Quindi, se voglio rendere possibile ai non sviluppatori di scrivere queste classi la via da percorrere sembra essere il modo dichiarativo, sono quasi certo di non poter eliminare le dichiarazioni di regex, che chiaramente richiedono (senior: D) programmatori, quindi dovrei preoccuparmene? Pensi che sia importante sceglierne uno rispetto a un altro o non importa affatto? Forse se qualcuno vuole lavorare su questo progetto, lo farà, se non lo farà, indipendentemente dall'idioma che scelgo. Posso "convertire" i non programmatori per aiutarli a svilupparli? Quali sono le tue osservazioni?
Altre considerazioni: Imperativo consentirà qualsiasi tipo di lavoro; c'è un flusso semplice, che possono seguire ma al loro interno possono fare tutto ciò che vogliono. Sarebbe più difficile forzare un'interfaccia comune con imperativo a causa di queste implementazioni arbitrarie. Il dichiarativo sarà molto più rigido, il che è una cosa negativa, perché i formati potrebbero cambiare nel tempo senza preavviso. Dichiarare sarà più difficile per me sviluppare e richiedere più tempo. Imperativo è già pronto per il rilascio.
Sto cercando risposte su quali idiomi utilizzare quando, il che è meglio per progetti open source con diversi scenari, che è meglio per una vasta gamma di capacità di sviluppo.
TL; DR:
- Analisi di diversi formati di file (testo normale, XML)
- contengono lo stesso tipo di informazioni
- Destinatari: non sviluppatori, principianti
- Probabilmente il regex non può essere evitato
- Sono necessarie 30-40 classi di parser concreto
- Facilitare la codifica di queste classi concrete
- Quale idioma è migliore?