Mi sono sempre ben visto dal cominciare a leggere Moby Dick per quell’alone da grande classico / mattone che ha sempre avuto. Poi quest’estate, in un impeto di letterario, l’ho comprato e soprattutto l’ho messo in cima alla lista dei libri da leggere. In realtà è più uno scaffale: io ho uno scaffale dove tengo solo i libri da leggere in un ordine, più o meno, di lettura consigliata. Si lo so, probabilmente ce l’hanno tutti ma era per precisare. Dopo quasi 5 mesi in cui più di una volta stavo per chiuderlo per sempre mi sono fatto forza e finalmente oggi l’ho finito. Embè? Direte voi… E’ proprio un mattone difficile da digerire. Direi che più che un romanzo è una sorta di trattato su balene e baleniere con tanto di dettagli scientifici, sociali, storici, geografici, linguistici… Davvero un lavoro enorme e articolato, ed è forse proprio per questo che mi ha reso la vita difficile. In effetti io mi attendevo un libro di grande avventura ed adrenalina con quel pazzo capitano Achab alla forsennata ricerca di fare la pelle al diabolico cetaceo che gli aveva avvelenato l’esistenza. Intendiamoci eh, c’è anche quello, anche se tutto sommato nelle sole ultime 50 pagine. Tutto il resto è una lenta preparazione in cui vengono fatte dissertazioni su tutte le specie di balene esistenti, e non avevo idea di quante potessero essere, di come le si caccino, di come una volta uccise vengano lavorate ed estratto il grasso di balena. Davvero un’istantanea di grande pregio sulle baleniere di metà ottocento e sul lavoro di chi le governava spesso tra mille difficoltà e problemi che noi oggi nemmeno ci possiamo immaginare. Se poi a tutto ciò uniamo uno stile letterario estremamente forbito e a volte eccessivamente tecnico, purtroppo per chi come me non ha grosse conoscenze letterarie e legge più che altro come passatempo, l’impresa diventa più ardita di quella dello stesso Achab.
Insomma, in fin dei conti non lo sconsiglio, perchè senza dubbio è un’opera di grande rilievo, ma vi metto in guardia: Moby Dick viene nominato la prima volta a pagina 200, sapete cosa vi attende…
Ormai ci ho preso gusto dopo le ultime puntate continuo a lavorare sul migliorare lo script di Log. Per cominciare vorrei dare l’opportunità a chi lo utilizza di decidere dove loggare. Come ricordate infatti al momento tutti i logs finiscono nella stessa cartella in cui c’è lo script e questo è limitante. Sarebbe figo invece che chi lo usa possa decidere di volta in volta dove loggare. Creeremo dunque una funzione Open-Log a cui dire come inizializzare dei parametri che poi si applichino.
# Get the current Directory
$_StoragePath = Split-Path -Parent $MyInvocation.MyCommand.Path
#Set the file log name
$_Logfile = "_StoragePath\XinLog_$($env:computername)_$((Get-Date).toString("yyyyMMdd_HHmmss")).log"
function Open-Log{
Param (
[string]$StoragePath
)
#set the folder name
$_StoragePath = $StoragePath
#Set the file log name
$_Logfile = "$_StoragePath\XinLog_$($env:computername)_$((Get-Date).toString("yyyyMMdd_HHmmss")).log"
}
Se invochiamo quindi questa Open-Log prima di utilizzarla, l’idea è che si inizializzi la variabile $_StoragePath e da lì in poi essa venga richiamata ogni volta nella Write-Log. Se però lo fate scoprirete che non funziona. Perchè? In pratica per come sono dichiarate le variabili sopra hanno un contesto limitato allo script che quindi cessa di esistere aldifuori del fil XinLog. Questo ovviamente non ci piace perchè se dobbiamo inizializzare ogni volta il file tutto perde di senso.
E’ il caso invece di giocare un pochino con le variabili e qui [1] trovate un articolo interessante in merito. E’ il caso che dichiari Global queste variabili così da riuscire a mantenere il valore nel contesto del thread lanciato e non solo del singolo file XinLog: Funziona!
# Get the current Directory
$global:_StoragePath = Split-Path -Parent $MyInvocation.MyCommand.Path
#Set the file log name
$global:_Logfile = "$global:_StoragePath\XinLog_$($env:computername)_$((Get-Date).toString("yyyyMMdd_HHmmss")).log"
function Open-Log{
Param (
[string]$StoragePath
)
#set the folder name
$global:_StoragePath = $StoragePath
#Set the file log name
$global:_Logfile = "$global:_StoragePath\XinLog_$($env:computername)_$((Get-Date).toString("yyyyMMdd_HHmmss")).log"
}
Come potete ben vedere l’unica accortezza è di utilizzare il prefisso $global: per tutte le variabili che vogliamo mantengano un valore che esuli dal singolo contesto di File e persistano anche nel Thread.
Infine aggiungiamo un po’ di try-catch per evitare che log (utilizzato anche per loggare gli errori) possa a sua volta bloccarsi per qualche eccezzione inattesa ed il gioco è fatto: la versione XinLog 1.1 è servita (GitHub [2])
Dopo aver cominciato il thread [1] delle scorse settimane, ho pensato fosse opportuno spendere qualche minuto in più per produrre una libreria separata per il logging con l’opportunità che essa possa essere riutilizzata anche in altri contesti. Essendo infatti il logging concettualmente un’azione riutilizzabile più e più volte in mille contesti distinti sarebbe bello che questa funzionalità stesse in un file separato e che fosse richiamabile semplicemente includendola nel contesto in cui mi serve.
Per questa ragione creo un un file ps1 separato che chiamerò XinLog in cui isolerò tutte le logiche relative al logging:
################# XinLog 1.0 ######################
# Use this library to log easely on file and screen
# In Parameters MANDATORY
# - $LogString [STRING] Message to log
# The log on file will create file a file in the same directory of the caller
###################################################
# Get the current Directory
$myDir = Split-Path -Parent $MyInvocation.MyCommand.Path
#Set the file log name
$Logfile = "$myDir\XinLog_$($env:computername)_$((Get-Date).toString("yyyyMMdd_HHmmss")).log"
#begin FUNCTIONS
function Write-Log
{
Param (
[Parameter(Mandatory)]
[string]$LogString
)
$Stamp = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
$LogMessage = "$Stamp - $LogString"
Add-content $LogFile -value $LogMessage
Write-Host $LogString -ForegroundColor White
}
#end FUNCTIONS
Non ho fatto granchè in realtà, ho semplicemente esportato le righe relative al logging dal file precedente così che il file contenga solo la funzione Write-Log (che scrive effettivamente il log) ed i settaggi che servono ad indivuare dove scrivere il log. Al momento questi settaggi non sono modificabili, ma chissà, in futuro…
A questo punto però come posso utilizzare la Write-Log se sta in un file separato? La risposta è ovviamente semplicissima, come in tutti i linguaggi è possibile includere uno script in un altro script, nella fattispecie in PowerShell questo si fa con la “dot source notation” descritta qui [2] in cui basta sostanzialmente includere il il file con il path specifico. Nel nostro caso il file Conto2.3 cambierà nel modo seguente:
########### CONTO 2.3.1 ############
# First test
####################################
##### Inclueded Libraries ##########
# Get the current Directory
$myDir = Split-Path -Parent $MyInvocation.MyCommand.Path
# Files included
. "$myDir\XinLog.ps1" # Include the file logs
####################################
#begin BODY
Write-Log "Text to write"
#end BODY
Per chi fosse interessato potete trovare anche uno progetto Git dedicato [3].
Come detto in fase di design [1], le logiche di ET andranno implementate in PowerShell script. Per chi non ha idea di che cosa si tratti niente paura: è semplicemente un linguaggio di scripting disponibile anzitutto su sistemi Microsoft (che lo ha sviluppato) ma installabile anche su Linux (non credo che abbia senso ma nel caso trovate qualche info qui [2]). L’idea è quella di avere un linguaggio un po’ più elaborato della semplice linea di comando mantenendo l’agilità e l’austerità della stessa.
Per cominciare a codificare in PowerShell vi serve davvero poco, praticamente solo un editor di testo. Io vi consiglio ad ogni modo di utilizzare Visual Studio Code [3] che è un editor gratuito, leggero e che supporta molti linguaggi di programmazione e dunque è in grado di supportarvi in maniera efficiente e anche di fornirvi una modalità debug che vi aiuta nel troubleshooting.
Tornando al nostro obbiettivo: è fondamentale definire una modalità per loggare, sia a schermo che su file le azioni effettuate. Per farlo creeremo una funzione ad-hoc chiamata WriteLog che avrà il doppio compito di scrivere su file ed a schermo le info che verranno passate.
La scrittura a schermo sarà effettuata tramite il comando Write-Host “stringa da scrivere”
La scrittura su file avverrà attraverso Add-content File -value “stringa da scrivere”
Inoltre nella scrittura su file aggiungiamo anche un timestamp che dica quando quel log è stato scritto.
Attenzione alla prima riga dove c’è la scritta Param: questo indica che tra parentesi si trovano i parametri che si possono passare alla funzione. Nel nostro caso è la stringa da loggare che, come vedete ha una dicitura Mandatory perché non avrebbe senso chiamare un log senza un messaggio da loggare.
Proviamo dunque ad invocare la funzione con un valore di test
WriteLog "Text to write"
Eseguendo lo script da linea di comando (oppure in debug dall’IDE di Visual Studio Code) ci troveremo a schermo esattamente la scritta che volevamo.
Esempio di WriteLog
Questo però non è sufficiente a scrivere su file perché in effetti dobbiamo in qualche modo definire qual’è il file da scrivere. Per farlo definiamolo come variabile il nome di un file generico da collocare nella stessa cartella del file Powershell.
La prima riga memorizza in $myDir il path relativo della cartella corrente. La seconda invece definisce il path del file di log aggiungendo il nome della macchina fisica aggiungendo un timestamp per evitare problemi di sovrascrittura generando di fatto un nuovo file di log ad ogni run. Se ora rilanciamo lo script troveremo un file di log nella cartella con questo contenuto
File di log generato
Contenuto del file di log
Una cosa molto interessante di PowerShell è come sia semplice comporre delle stringhe sfruttando i valori delle variabili: $LogMessage = “$Stamp – $LogString” semplicemente introduce i valori delle variabili nel testo senza altri comandi. Davvero veloce e pratico.
Ricapitolando: abbiamo creato una prima versione del nostro PowerShell script che in questo momento logga su file ed a schermo un testo. Il dettaglio dello script lo trovate sotto. Per maggior facilità di lettura la funzione WriteLog è dichiarata nella prima parte dello script mentre verrà richiamata nella seconda parte dello script. Non è una necessità, lo script funziona uguale anche se la funzione è dichiarata a valle, è semplicemente una convenzione mia.
#begin FUNCTIONS
function WriteLog
{
Param (
[Parameter(Mandatory)]
[string]$LogString
)
$Stamp = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
$LogMessage = "$Stamp - $LogString"
Add-content $LogFile -value $LogMessage
Write-Host $LogString -ForegroundColor White
}
#end FUNCTIONS
# Get the current Directory
$myDir = Split-Path -Parent $MyInvocation.MyCommand.Path
#Set the file log name
$Logfile = "$myDir\log_$($env:computername)_$((Get-Date).toString("yyyyMMdd_HHmmss")).log"
WriteLog "Text to write"
Trovate qui [4] lo zip con il file per provare a vostra volta.
Se siete giunti al secondo capitolo, significa che probabilmente qualcosa vi interessa dell’argomento e conseguentemente una volta espressi i requisiti (se ve li siete persi sono qui) possiamo passare alla parte più di concetto vale a dire definire almeno sulla carta come dovrà funzionare tutto il processo. In particolare:
definire come strutturare la parte di input / output identificando dove saranno implementate le parti operative (chi fa cosa)
impostare una configurabilità delle parti sopra che ci consenta la riusabilità e la flessibilità che ci servono
impostare un sistema di logging che ci permetta di verificare con facilità se ci sono problemi, anomalie o semplicemente verificare nel dettaglio che cosa il sistema abbia realizzato
1) Definire come strutturare la parte di input / output
Come dicevamo l’idea è che sia necessario gestire tipologie di files diversi a seconda del tipo di sorgente: estratto conto della banca o della carta di credito e di chi appartengono questo perché se io e mia moglie abbiamo due banca distinte normalmente anche la sorgente sarà differente ed è dunque necessario prevedere che possano essere due caricamenti differenti.
Configurazione cartelle di source
L’idea di base è che volendo potrei aggiungere quanti owner io voglia tenendo al di sotto una struttura che consenta di identificare anzi tutto la banca e poi altre fonti. Nelle cartelle sopra dovranno essere caricati tutti i files sorgente così come sono senza tendenzialmente effettuare nessuna manipolazione.
A questo punto uno script PowerShell che risiederà nella root acquisirà questi files e li deve normalizzare. Che cosa si intende per normalizzare? Sostanzialmente ricercare un insieme di colonne che siano necessarie ad estrarre le informazioni che servono:
Data Operazione: la data in cui la spesa o l’entrata è avvenuta o contabilizzata (scegliete voi quale delle due preferite)
Causale: dovrebbe dare un’indicazione di massima dell’operazione
Descrizione: indica con più dettagli la motivazione della stessa operazione
Ammontare: indica la somma monetaria dell’operazione
Accredito: per esperienza alcune banche posizionano l’accredito in una colonna separata invece di includerlo con un segno differente nell’ammontare
Una volta acquisite queste info andranno quindi esportate in un folder OUTPUT anche questo suddiviso in in due principali cartelle che però conterrà le info degli stessi file originali ma senza più distinzioni di owner e soprattutto nel medesimo formato al fine, come vedremo di rendere la vita più semplice ad Excel.
Configurazione Cartelle di output
L’ultimo miglio riguarda proprio Excel che dovrà andare a leggere questi files e caricarli all’interno dei suoi fogli in modo da poter rendere fruibile una pivot che li aggreghi.
All’appello manca però ancora una parte importante che è il mapping. Chi fa il mapping e da dove lo attinge. Questa purtroppo è la parte più dolorosa, infatti il mio obbiettivo è quello di gestire il mapping in un file excel separato adibito solo a quello in cui sia possibile dire che determinate descrizioni sia catalogabili in un modo piuttosto che in un altro. Questa possibilità purtroppo è assai costosa ed è il motivo principale per cui Excel da solo non basta e serve Powershell. In pratica, appena lanciato Powershell si caricherà in pancia le informazioni presenti nel file di mapping e le utilizzarà per mappare le spese in un maniera coerente cosicchè in OUTPUT mi troverò già dei files con le info che mi serviranno a categorizzarli a dovere.
2) Impostare la configurabilità
Tutto ciò che è stato definito sopra ha senso ma perché sia facilmente estendibile e riadattabile necessita che sia presente un file di configurazione che dica al processo che tipo di info servono e dove reperirle così che se qualcuno o qualcosa cambia le carte in tavola non serva mettere mano allo script ma solo rivedere le configurazioni impostate. E’ un elemento fondamentale al fine di rendere l’applicazione utilizzabile.
3) Definire come loggare
Infine al fine di avere un’informazione più di dettaglio su cosa è accaduto e quali sono state le azioni per verificare sia tutto ok serve anche che il sistema logghi tutto su un file che possa essere utilizzato a valle di ogni singolo run
Root Folder
Insomma ricapitolando:
Config.xml: sarà il file che contiene le configurazioni
Conto2.3.ps1: sarà il file dove verranno implementate le logiche di ET
Conto2.3.xlsx: sarà il file Excel che effettuerà la parte di L e genererà la pivot
MasterCategories.xlsx: sarà il file dobe risiedono i mapping per la categorizzazione usato dunque nella fase di ET
Non so a voi ma l’idea che ogni mese debba ripetere una serie di procedure, spesso parecchio manuali per avere un quadro delle entrate ed uscite di casa mi rende sempre piuttosto annoiato e nervoso. In realtà ci sono già parecchi tool che possono essere utilizzati, come Excel ad esempio, solo che hanno delle limitazioni e la mia idea era partire da un sistema che una volta configurato necessiti poco più di un paio di click per aggiornarsi ogni mese.
Spoiler: l’impresa è ardua e non sono del tutto sicuro di esserci riuscito, ma se mi seguirete in tutto il post ed anche nei seguenti (penso e spero) potrete giudicare voi stessi.
Ma iniziamo dal requisito:
Le fonti da cui arrivano le spese possono essere multiple: il mio conto corrente, quello di mia moglie, l’estratto conto della carta…
I formati di questi files sono spesso differenti principalmente csv e xlsx ma potrebbero essercene anche altri
Il contenuto che questi files hanno potrebbe essere differente: dalle colonne presenti al formato dei numeri e delle date
L’idea è che tutti questi files eterogenei vengano acquisiti, mappati e convogliati in unico files Excel da cui si possa con facilità applicare delle Pivot e capire questo mese quanto sto spendendo verificando se una voce è più onerosa di altre.
Infine che ogni mese, salvo caricare i nuovi files ed eventualmente correggere qualche mappatura, con un paio click si aggiorni tutta la baracca
Un punto molto importante riguarda il mapping. Già, perché così come sono le informazioni che ci arrivano dai files sono spesso poco significative. Mi spiego meglio: mi piacerebbe che se nel file fosse presente una linea “Pizzeria da Mario” questa finisca sotto una voce di spesa tipo “Pranzi e Cene” così che poi sia di più facile lettura o ancor meglio che tutte le pizzerie ci finiscano. Non basta quindi acquisire il dato in se per se ma operarne una trasformazione: quello che in gergo tecnico ed anche abbastanza NERD (si userà ancora questo termine? boh) si chiama ETL. L’acronimo deriva dall’inglese Extract, Transform and Load che per chi adora gli spaghetti come me si traduce in Estrai, Trasforma e Acquisci.
Come già accennavo all’inizio, ci sono fiumi di tools più o meno complessi e costosi che forniscono questo tipo di funzionalità, ne cito solo uno perché lo conosciamo tutti benissimo: si chiama Excel. Purtroppo però, probabilmente per mia ignoranza non sono riuscito ad individuare un unico tool economico che fornisse questo tipo di esperienza per cui ho optato per l’utilizzo combinato di due tool rispettivamente suddivisi nella maniera seguente:
Extract: Powershell
Transform: Powershell
Load: Excel
Un po’ più nel dettaglio: con Powershell verranno identificati i files sorgente, verranno letti e normalizzati i dati in essi contenuti effettuando anche il mapping tanto desiderato e verranno quindi tradotti in un formato definitivo. Questo formato definitivo verrà poi dato in pasto ad Excel così da fornirci una pivot che sia utilizzabile per i nostri scopi di monitoraggio e amministrazione e soprattutto fruibili anche a vostra moglie…
Arriviamo
alla gara con il Maccesfield in piena emergenza: Preece non ha ancora
recuperato mentre Marshall, Walker e Harsly hanno speso tutto nella gara di
mercoledì. Devo fare qualche azzardo. Alla fine opto per mettere due terzini
come esterni di centrocampo: Akhmedov a sinistra e Blamey a destra. In attacco
ci sono Ormondroyd e Forrester. La partita inizia subito male, dopo venti
minuti perdiamo 1-0. Con l’assetto corrente non riusciamo a combinare granchè e
ad inizio secondo tempo tolgo il solito apatico Akhmedov ed inserisco Marshall
sulla destra spostando Blamey sulla sinistra. Riusciamo a guadagnare campo ma
anche l’inserimento di Harsley non dà profitto. Finisce 1-0 ed al solito, loro
ci hanno fatto gol con l’unico tiro in porta…. Il mercoledì dopo c’è il
Rotherham per il second turno del Windscreen Shield. In attacco è un vero
disastro 3 giocatori su 4 sono in infermeria. Perdiamo 3-0 e siamo fuori.
3 Infortunati su 4 in attacco
Il sabato
giochiamo il secondo turno di FA Cup e vinciamo 4-1 contro lo Stalybridge.
Doppietta di Ormondroyd e reti Preece (MoM) e di Crosby. E’ stata una
passeggiata, il prossimo turno ci sarà l’Ipswich Town di prima divisione: sarà
dura.
Finalmente un po’ di riposo e qualche giorno in più per recuperare nerbo. Giochiamo l’ultima di andata in casa contro il Bristol C sotto di noi di soli 4 punti. Dominiamo ma non centriamo mai la porta e finisce sostanzialmente 0-0. Senza Harsley e Mainwaring purtroppo se non ci pensa il vecchio Ormondroyd non si riesce mai ad infilare la porta…
Dopo la scorpacciata di partite casalinghe mi preparo alla gara in trasferta sul campo del Barnet. Nel frattempo mi arriva un’offerta per Sertori, la situazione finanziaria è abbastanza disastrosa, ma non posso privarmi del migliore difensore in termini di contrasti e colpi di testa. Tengo duro, rifiuto. Vista la situazione economica rinnovo Marshall, Hope ed Ormondroyd che erano tra i giocatori in scadenza di contratto. Non posso permettermi di perderli. Restano ancora 5 giocatori in scadenza: Walker, Clarke, Housham, Wilcox e Shakespear. Clarke e Housham non saranno di sicuro rinnovati. Wilcox certamente se lo meriterebbe mi lascia solo un po’ perplesso l’età (ormai 34)…
La partita con il Barnet è un mezzo disastro, subiamo con continuità e creiamo pochissimo il risultato è l’unica cosa salvabile: 2-2. Non un gran viatico in vista della prossima trasferta sul campo del Peterborough. Con il Rientro in pianta stabile di D’Auria dietro le punte il duo d’attacco titolare diventa Harsley-Mainwaring. Vinciamo meritatamente 1-0 con un gol proprio di Harsley. Dopo due mesi in cui si è giocato sempre ogni tre giorni finalmente non c’è il turno infrasettimanale. Riceviamo il Darlington e Mainwaring sfodera il primo hattrick della sua giovane carriera: finisce 3-0 con tanto di primo MoM. Ancora una settimana e affrontiamo il Cardiff in trasferta e finisce come spesso è accaduto negli scorsi mesi: 2 tiri 2 goal per loro e noi a sprecare troppo. Il mercoledì successivo nella seconda gara del Windscreen Shield otteniamo un bel 2-2 sul campo del Grimsby che ci consente di chiudere al primo posto nel girone.
Tre giorni
dopo giochiamo il primo turno di FA challenge in casa contro Altrincham, la
partita è molto chiusa e non ci sono molte occasioni: finisce 0-0 dopo i ’90
minuti. Si dovrà replicare tra una settimana.
Il 14 Novembre riceviamo il Northampton poco sopra di noi in classifica, è una di quelle gare dove serve fare punti per mille ragioni differenti. Dopo tre minuti la tegola: Mainwaring si accascia è strappo (credo) al polpaccio. Il Nothampton domina e vince 4-2. Nel dopo partita la cattiva notizia: Andrew sarà fuori 4 mesi…
L’infortunio di Mainwaring
La prossima
gara è la ripetizione della partita con l’Altrincham. Preece è appena tornato
dall’infortunio e non ancora in condizione. Sulla sinistra do’ un turno di
riposo a McAuley e schiero Akhmedov. Il primo tempo scorre senza molte
emozioni. Al 60′ Marshall di testa ci porta in vantaggio. A quel punto
l’Altrincham prova la reazione ed un paio di buoni interventi di Colgan
blindano l’1-0 finale. Il sorteggio ci arride affronteremo il Stalybridge una
squadra delle serie minori: il terzo turno è alla nostra portata.
Il 26
Settembre riceviamo il Lincoln quinto in classifica. Brutto cliente, ma dopo
due vittorie in tre partite sarebbe importante mettere in fila due vittorie
consecutive. La parita rimane in equilibrio sul filo dello 0-0 ma al 72′
andiamo sotto e non riusciamo più a pareggiare. Ormondroyd da mezza punta al
posto dell’infortunato D’Auria è troppo lontano dalla porta. Mainwaring gioca
una buona mezzora senza produrre granchè. Si gioca ogni tre giorni e quindi il
sabato successivo andiamo a giocare sul campo dell York fanalino di coda.
Finisce in goleada, segnano tutti gli attaccanti, Harsley firma persino
doppietta e Preece è MoM. Anche Mainwaring rompe il ghiaccio segnando il primo
gol tra i professionisti. Risaliamo alla 13ma posizione.
Il mercoledì
successivo va in scena la prima gara del girone del Windscreen Shield e
giochiamo contro il Preston, squadra di seconda divisione. Vista la minore
importanza del torneo rispetto al
campionato opero qualche cambio: posiziono Hope al posto di Wilcox e
Mainwaring dall’inizio a fare coppia con Harsley. Dominiamo la gara e
soprattutto Mainwaring fa doppietta 2-0. E’ nata una stella? La gara successiva
è sul campo del Mansfield. Dopo la pausa rimetto Ormondroyd titolare al centro
dell’attacco con Harsley e tengo Walker a centrocampo optando per un classico
4-4-2. Dopo 2 minuti, Ormondroyd si infortunia e tocca dunque a Mainwaring
prenderne il posto. Vinciamo 2-1 con rete decisiva proprio di Mainwaring, il migliore
in campo è però Colgan. Terza vittoria di fila tra campionato e coppe e
soprattutto 5 vittorie nelle ultime 7 gare e decima posizione in classifica ad
un soffio dalla zona playoffs, che finalmente sia arrivata la svolta?
Teoricamente
il calendario è buono: abbiamo 4 partite casalinghe di fila e con po’ di
fortuna potremmo davvero ingranare un buon passo ed attestarci ad una buona
posizione di classifica. La prima è contro il Rotherham penultimo e dunque
vittima designata. Andiamo sotto quasi subito, Harsley pareggia al 70′ ma 5
minuti dopo Walker commette il più classico degli autogol ed invece di tre
punti facili ci ritroviamo con un pugno di mosche: 1-2. Tre giorni dopo è la
volta del Brighton settimo in classifica. Partita di grande equilibrio come
quella con il Rotherham e ache qui andiamo sotto, recuperiamo con Ormondroyd ma
non è sufficiente e subiamo il 2-1 nel finale. La terza gara è contro il
Shrewsbury sesto in classifica. Finisce 1-1 con il portiere avversario che
prende 9! Di positivo c’è che Mainwaring va ancora a segno. L’ultima della
serie di gare casalinghe è contro il Swansea sopra di un paio di punti in
classifica. Il clichè è pressochè lo stesso delle altre gare: finisce 0-1 dopo
aver avuto anche buone occasioni, probabilmente 1-1 sarebbe stato un risultato
più giusto ma il loro portiere Jones è MoM. Così dopo un un punto in quattro
partite ci ritroviamo di nuovo al 13mo posto in classifica.
Rotto il ghiaccio si spera finalmente di cominciare a macinare qualche bella vittoria e magari tenersi nella parte alta del tabellone con vista playoffs. La gara successiva è in trasferta contro il Rochdale squadra da primi posti e quindi un buon test. Dominiamo letteralmente la gara ma non centriamo ma la porta: 10 tiri fuori ed uno solo nello specchio. Finisce 0-0 tra mille rimpianti. Si poteva vincere ma l’attacco aveva proprio le polveri bagnate. E’ evidente che in attacco serve un impatto maggiore. Devo trovare un buon attaccante, uno che veda la porta con continuità. Il problema sono i soldi, che mancano.
Tabellino dell’incontro con il Rochdale
Il mercoledì successivo riceviamo l’Harlepool ed è ancora 0-0, mentre la partita successiva è un’altra sconfitta per 2-1 sul campo del Bournemouth dove perdipiù riperdiamo Preece questa volta per infortunio. La situazione è parecchio sconfortante in poco più di 20 giorni in cui si è giocato ogni 3 per un totale di 7 gare ne abbiamo perse 4 e vinta una sola. Va così in scena una gara pressochè grottesca contro l’Altrincham. E’ un tiro segno 18 tiri a 3 ma finisce 1-1 nell’unica occasione loro segnano mentre noi sprechiamo l’impossibile e solo l’eterno Ormondoryd ci evita una vera e propria beffa. Un tiro un gol dicevamo e purtroppo in porta c’è chi avevo individuato essere il futuro del ruolo in squadra: Colgan. Evidentemente non è stata una scelta stra-azzeccata. Cmq il messaggio è chiaro: mi serve qualcuno che la butti dentro. Comincio a cercare tra chi costa poco, anzi, praticamente nulla. Nel valutare possibili soluzioni mi imbatto in Andrew Mainwaring, dotato di ottima tecnica e buon tiro. E’ privo di squadra e quindi posso proporgli anche un contratto contenuto.
Andrew Mainwaring
Nel mentre andiamo a giocare sul campo del Notts County in 4 posizione e con velleità assai diverse dalle nostre. Dominiamo la gara e complice anche l’espulsione del portiere avversario non corriamo grossi pericoli. Un bel 2-0 che ci fa tirare una bella boccata d’aria. Ormondroyd è il Man of the Match. Galvanizzati da questa vittoria riceviamo il Leyton Orient e per la gara si aggrega anche Mainwaring appena firmato il contratto. E’ l’ennesima doccia fredda finisce 3-4 e dopo aver subito 3 gol nelle ultime 5 gare ne prendiamo ben 4 tutti in una volta, questa volta in porta c’era Evans ma… il problema del portiere rimane. A fine gara faccio esordire Mainwaring ma solo per uno scampolo di minuti senza peraltro lasciare traccia. La gara successiva è quella che posso definire una delle più assurde abbia mai giocato: la vinciamo finendo la gara in 9 e con gli avversari che sprecano du calci di rigore. Evans si fa cacciare al 4 minuto e dato che in panca non ho altri portieri schiero tra i pali Forrester. Ormondroyd ci porta avanti ed Harsley raddoppia, quando però al 74 rimaniamo in 9 comincio a disperare, fortunatamente Steiner calcia alle stelle anche il secondo rigore. Finisce 1-2 con un po’ di patemi mah… insomma in 9 con un attaccante in porta…
This website uses cookies so that we can provide you with the best user experience possible. Cookie information is stored in your browser and performs functions such as recognising you when you return to our website and helping our team to understand which sections of the website you find most interesting and useful.
Cookie strettamente necessari
I cookie strettamente necessari dovrebbero essere sempre attivati per poter salvare le tue preferenze per le impostazioni dei cookie.
Se disabiliti questo cookie, non saremo in grado di salvare le tue preferenze. Ciò significa che ogni volta che visiti questo sito web dovrai abilitare o disabilitare nuovamente i cookie.
