Durante una revisione del codice, mi sono imbattuto in un'idea interessante, che non posso giudicare correttamente da sola.
È corretto migliorare la leggibilità del codice mediante una sintassi del linguaggio non ampiamente conosciuta? Quando lo scrittore originale non utilizzava una sintassi speciale designata per risolvere uno specifico problema di codifica e lo risolveva simulando con soluzioni alternative, vale la pena di ridefinirlo per chiarezza e concisione? Cosa accadrebbe se anche il revisore del codice non fosse a conoscenza della funzione della lingua?
Per essere precisi, porterò il problema esatto che ho incontrato sulla revisione del codice, ma tieni presente che questo è solo un esempio.
Quindi il codice originale era un piccolo servizio web in Python. Ad un certo punto, è emerso un requisito per diversi gestori di richieste da proteggere con un meccanismo di autenticazione. Qualcuno l'ha risolto con l'ereditarietà:
class AuthOnlyAccess:
def GET(self, *args):
if not hasattr(self, 'PROTECTED_GET'):
raise web.Nomethod()
if check_auth():
return self.PROTECTED_GET(*args)
else:
raise web.Unauthorised()
def POST(self, *args):
if not hasattr(self, 'PROTECTED_POST'):
raise web.Nomethod()
if check_auth():
return self.PROTECTED_POST(*args)
else:
raise web.Unauthorised()
...
class FooHandler(AuthOnlyAccess):
def PROTECTED_GET(self, a, b, c):
handle_foo_get(a, b, c)
def PROTECTED_POST(self, x, y, z):
handle_spam_eggs()
...
<more handlers deriving AuthOnlyAccess>
Il refactorer ha trovato questo codice brutto e ha introdotto un decoratore:
from functools import wraps
...
def requires_auth(wrapped_func):
""" (a little doc telling that this is a decorator and how to use it) """
@wraps(wrapped_func)
def decorator(*args):
if check_auth():
return wrapped_func(*args)
else
raise web.Unauthorized()
return decorator
...
class FooHandler:
@requires_auth
def GET(self, a, b, c):
handle_foo_get(a, b, c)
@requires_auth
def POST(self, x, y, z):
handle_spam_eggs()
...
<more refactored handlers>
Il revisore sostiene che questa modifica effettivamente riduce la manutenibilità, perché la maggior parte del team non conosce la sintassi del decoratore. Quindi la prossima persona che visita il codice refactored potrebbe essere confusa dal costrutto, ma non con la versione precedente.
C'è anche un argomento convincente che la maggior parte del codebase non è in Python , (il linguaggio è lì solo per quel piccolo servizio web), e quindi ai membri del team non è richiesto di avere conoscenza superficiale di Python. Tuttavia, per lavorare con il codice, è necessario conoscere la sua lingua, giusto?
E se hai la tentazione di dire che i decoratori python non hanno la sintassi avanzata quella , tieni presente che questo è solo un esempio. Ogni lingua ha i suoi angoli oscuri. (Ma imparare quegli angoli significa diventare migliori.)
Quindi la domanda è ... Puoi leggere la sintassi sconosciuta? L'eleganza merita la sorpresa? Almeno, quali sono i compromessi e / o le linee guida che puoi nominare? Ho davvero bisogno di alcune opinioni dalla comunità dei professionisti della programmazione.