Ancora su j – Autojump e source

Il post su Autojump  è piaciuto. E pensare che l’idea ce l’avevo da parecchio tempo, non so quante volte ho cominciato a scriverci e poi lo abbandonavo perché non mi piaceva 🙂

OK, postandolo ci sono stati i commenti con suggerimenti e precisazioni. E adesso è tutto molto più chiaro. Vorrei allora chiudere l’argomento con questa breve nota, approfittando della vostra pazienza 😉

Il suggerimento di Marco Delmastro (il suo blog, Borborigmi  è über-yotta-mitico) di usare source funziona, da approfondire.

Il prof Lipari, glipari ha indicato il metodo usato da Autojump, un post di StackOverflow. Era stato glipari che mi aveva fatto conoscere Autojump e sospendere i miei tentativi di ricreare j con Linux.

Il commento di bit3lux / Luigi dà una soluzione che funziona ma “non è elegante“, come illustrato nel commento di glipari. Si vede che Luigi è troppo giovane: quando non c’era l’ambiente grafico ormai pervasivo il terminale era tutto per la shell. E potevi (OK, anche adesso) avviare una sub-shell digitando sh (non bash o csh, non usare mai quei nomi). Non so se il termine è corretto ma da noi si diceva che attivavi una sessione ospite. Con ctrl-D o exit uscivi da questa sub-shell e tornavi a quella precedente. Nulla vietava di annidare sub-shell per più livelli anche se 1) non so bene a cosa potesse servire; e 2) consumava memoria. Con tanti ctrl-D quanti erano i processi attivati tornavi alla shell originale; se ne battevi uno in più ti slogavi (c’era una variabile da settare per evitare che ciò avvenisse, la usavano solo i niubbi che allora si chiamavano pivelli).

Autojump di Joël Schaerer è perfetto, auto impara quali sono le directory che vengono usate e dimentica quelle vecchie; usa un algoritmo per indovinare quello che vuoi impiegando una regular expression (RegEx, RE) da paura. E poi Python è un linguaggio di script trendy e simpa (i francesi come Joël dicono così). Certo, seguendo l’indicazione di Marco si potrebbe fare a meno di Python, magari coinvolgendo Perl per la RE 😉

Non credo che mi avventurerò per questa strada ma per source ho provato a googlare un pochino. Ecco cosa ho scovato.

source
Avendo a disposizione il SysV Command Reference di Apollo, novembre 1989 ho voluto indagare se source c’era già in Unix-SysV. Pare di no. Il manuale ha la Section 1 –quella che m’interessa– e la Section 6 –games. I comandi sono in ordine alfabetico. A p.1-511 (si apre automaticamente lì) inizia SH(1), la Bourne shell, occupa le pagine fino a 1-523 compresa. Rimanda a pagine di SysV Programmer’s Reference che non ho. Non cita source.

CSH(1), la c-shell inizia a p. 1-91 e arriva fino a p. 1-115 compresa.
E c’è source, a p. 1-108, copio:

source name
Read commands from name. You may nest source commands, but if you nest too many deeply, the shell may run out of file descriptors. An error in a source at any level terminates all nested source commands.

source -h name
Place commands in the history list without executing them. Normally, input during source commands is not placed on the history list.

KSH(1), la Korn shell è descritta nelle pagine da 1-295 a 1-323. Ebbene sì Apollo permetteva di usare la shell che volevi, bash non c’era ancora. Nessun riferimento a source.

Idea per il futuro: se a qualcuno interessa potrei mettere le scansioni di queste pagine e magari incorrere nelle ire di HP.

A p. 1-528 c’è SORT(1) e a p. 1-529 SPELL(1) che continua anche sulla successiva, niente source quindi.

OK! source è nato in BSD e SysV non ce l’aveva. Mistero il motivo per cui tutti (a quanto pare) usassero la Bourne shell quando c’era la Korn, più nuova, almeno a giudicare da com’è ridotto il manuale.

E per Linux? Tanti, credo, sanno che si può usare source quando si modifica ~/.bashrc ma solo quello. Tranne Marco 😀 e pochi altri.
La googlata per source è stata fruttuosa, ecco

http://www.cyberciti.biz/faq/linux-bsd-unix-source-command/
nixCraft è un sito da bookmarkare, imho. Toh! lo dice anche qui che è BSD.

http://bash.cyberciti.biz/guide/Source_command
stesso sito, altra pagina, Linux (credo).

http://webtools.live2support.com/linux/period.php
Web Tools, lo sapete che source può essere scritta come . (punto, dot)? Da bookmarkare anche questo, sempre imho.

http://ss64.com/bash/
An A-Z Index of the Bash command line for Linux. Già che ci siete  bookmarkate anche questo.

Ah questa non la sapevo:

Visto: source – Esegue comandi da un file nella shell corrente.
Nella shell corrente.

Quante cose ci sono da imparare! E quante cose so di non sapere (cit.).
Riuscirò mai a diventare quasi-geek o rimarrò per sempre un aspirante-geek? 😉

Autojump

Posso raccontarvi un po’ di storia personale? Sì?
OK, allora quando ho iniziato a lavorare mi sono trovato un minicopmuter (mini è fuorviante, pensate a un armadio grosso) tutto mio. Cioè no ma da gestire.
Era, l’ho già detto altre volte, un Prime, anzi PR1ME.
E era arrivato un Prime perché degli amici e colleghi avevano il Prime (il loro capo era appena tornato da MIT, vicino a Natick, dove c’era la fabbrica dei Prime –bei tempi, sigh!
Uno dei miei amici (anche se non ricordo chi) aveva deciso di semplificare il comando cd (sì, sul Prime non si chiamava cd ma attach, abbrevviabile in a; come per il VMS del Vax i comandi potevano essere abbreviati, basta che non ci fossero conflitti, ancora meglio del tab di Unix/Linux).
Per cui A LAVORI 1 2 poteva essere scritto J L. Bella comodità, l’avevo adottata al volo. E poi questo comando l’ho rifatto per MS-DOS, prima come batch command e poi con Turbo Pascal, antenato di Delphi.

Poi ho provato a farlo anche su Linux, e non ci sono riuscito. Adesso vi faccio vedere il perché.

Con Windows si può creare questo semplice script (loro non li chiamano script ma è uno script), j-t-w.bat

@echo off
c:
cd C:\DOCUME~1\Alice\IMPOST~1\Temp
echo sei in
cd
echo fatto.

eseguendolo nel Prompt dei comandi otteniamo

Come si vede al termine dello script la directory corrente è diventata Temp sul disco C:.
Proviamo a fare la stessa cosa con Linux, ecco lo script t.sh

#!/bin/sh
cd /tmp
echo sei in $(pwd)
echo fatto.

provo a eseguirlo

OPS! non funziona. Durante l’esecuzione dello script è effettivamente in /tmp ma quando lo script termina mi ritrovo nella directory di partenza. OK, la cosa è logica e naturale, Linux (e Unix prima) sono fatti meglio ma non fa quello che volevo. E non è facile farglielo fare.

La cosa all’inizio mi dava parecchio fastidio e ogni tanto riesumavo il progetto, senza concludere nulla. Cioè c’ero riuscito in un paio di modi ma non eleganti. Poi qualcuno (credo sia stato il prof Lipari ma non riesco a rintracciare il link) mi ha segnalato Autojump di joelthelion – Joël Schaerer.

Dai, non era facile: bravo Noël, le lion! C’è riuscito con due script, uno tranquillo in Python e uno terribile in bash (e zsh, per chi usa questa shell). Noël è davvero un leone.

Autojump –in realtà si usa il comando j, proprio come facevamo su Prime, anche se allora j derivava da join– lo trovate nel Software Center di Ubuntu ma conviene installare l’ultima versione da github.

Per chi usa spesso il terminale è comodo, anche se ogni tanto mi fa ricadere nella tentazione di capire come funziona.

Era da un po’ che non mi capitava poi qualcuno ne ha parlato recentemente e mi sono deciso a prendere il toro per le corna: vediamo se questo post mi libera da questa ossessione.

Ah! visto che i miei amici Bit3Lux e Lightuono stanno portando avanti un corso di bash, questo post è dedicato a loro 😉

e ancora: bc, Python e newLISP

Continuo le prove iniziate in e Nepero e Eulero e il Fortran  anche se rischio commenti di Hon-ki-ton (no, dai, benvenuto! e benvenuti i commenti).

Allora il Fortran con la fama di number cruncher che si ritrova non mi sembra che si sia comportato benissimo. E se provassi con qualche altro linguaggio?

OK, c’è bc con la precisione che vuoi e 40 anni di servizio, una sintassi simile al C, anzi migliore, come il C dovrebbe essere, proviamo

scale = 15
m = 1000
eps = 1 / m
for (c = 0; c < 3; c++) { 	eps /= m } print "eps = ", eps, "\n" eprec =0. n = 1. delta = 10. i = 0 cm = 100 * m while(delta > eps) {
	e = (1 + 1 / n) ^ n
	print n, " ", delta, " ", e, "\n"
	n += cm
	i += 1
	if (e > eprec) {
		delta = e - eprec
	} else {
		delta = eprec - e
	}
	eprec = e
}
print "valore accettabile è stato raggiunto con ", i, " iterazioni\n"
print "con delta = ", delta, "\n"

quit

Una piccola precisazione: non mi va di correggere lo script; al momento di scriverlo non ricordavo la sintassi per i numeri esponenziali e il collegamento a internet era giù. Poco male, quattro righe quando ne bastava una.

L’esecuzione non è andata come previsto: l’ho interrotto dopo 12 ore perché il ‘puter (2 CPU a 2.4 GHz) aveva il fiatone e eravamo ben lontani dalla meta. Comunque ecco

Sconsolante! Ma aspetta: io sono affezionato a Python, chissà, proviamo dai

#!/usr/bin/env python
# -*- coding: utf-8 -*-

eps = 1e-12
print "eps =", eps

eprec = 0
n = 1.
delta = 10.
i = 0
cm = 100000
while (delta > eps) and (i < 1000):
	e = (1 + 1/n) ** n
	print i, n, delta, e
	n += cm
	i += 1
	delta = abs(e - eprec)
	eprec = e

print "valore accettabile è stato raggiunto con ", i, " iterazioni"
print "con delta = ", delta

Non ce la fa e allora metto un limite alle iterazioni, diciamo 1000, ecco, velocissimo

Dai, quasi buono, e soprattutto usabile al posto di bc. Ma un attimo ancora: chissà newLISP il linguaggio di scripting migliore in assoluto, quello che davvero preferisco e non mi ha mai deluso, tranne il modulo per la gestione dell’ambiente grafico ma quello è scritto in Java. Vediamo

(set-locale "C") ; l'abitudine
(set 'eps 1.e-12)

(set 'eprec 0.
	 'n 1.
	 'delta 10.
	 'i 0
	 'cm 100000)

(while (and (> delta eps) (< i 4000))
	(begin
		(set 'e (pow (add 1 (div 1 n)) n))
		(println i " " n " " delta " " e)
		(set 'n (add n cm)
			 'i (+ i 1)
			 'delta (abs (sub e eprec))
			 'eprec e
		)
	)
)

(println "valore accettabile è stato raggiunto con " i " iterazioni")
(println "con delta = " delta)

(exit)

Ho messo il limite a 4000 iterazioni, il risultato è simile a quello di Python. Anche lui velocissimo. Notare che dopo un po’ i numeri oscillano attorno al valore esatto; probabilmente erano sufficienti meno iterazioni.

Certo che una cosa così non me la sarei mai aspettata. Ma voglio dare un’ultima chance a bc

scale = 15
n = 5 * 10^5
ec = (1 + 1 / n) ^ n
print ec, "\n"
print e(1) - ec, "\n"
quit

Ho fatto un po’ di prove, aumentando via-via in valore di n, ecco il risultato dell’ultima, per n pari a mezzo milione; l’esecuzione ha richiesto qualche minuto.

Quindi? Ho imparato una cosa: non usare la definizione per il calcolo di e. Ci sarà un motivo per cui esiste una ricca letteratura, per esempio ecco Wiki 😀

Non so se è il caso di preoccuparmi: cercando per qualche immagine Google propone le mie a partire da p.9 😉

Quale linguaggio usare

Lasciamo sbocciare cento fiori
毛泽东

Il post di oggi –breve che fa caldo– è una continuazione del precedente. Anche se affronta un argomento leggermente diverso, come scoprirete presto continuando a leggere 8)

Mi sono trovato a dover traslitterare (mi hanno detto che si dice così) in minuscolo il contenuto di un file, lungo e pieno di parole astruse. A farlo a mano ci sarebbe stato un grosso rischio di inserire errori, e poi è poco elegante.

Siccome stavo facendo altre cose con newLISP la decisione spontanea, immediata è stata di usarlo. Ed ecco cosa ne è uscito (tolower.nl)

#!/usr/bin/newlisp

;; converte il file in minuscolo

(set 'argv (main-args))
(set 'narg (length argv))
 
; il primo indice dei parametri è pex + 1
(if (find "newlisp" (argv 0))
	(set 'pex 1)
	(set 'pex 0)
)

; file da convertire
(if (> narg pex)
	(set 'sorgente (argv (++ pex)))
	(begin
		(println "nessun file")
		(exit)
	)
)

(if (not (file? sorgente))
	(begin
		(println "manca il file " sorgente)
		(exit)
	)
)

(set 'text (read-file sorgente))
(set 'text (lower-case text))

(set 'bak (join (list sorgente "bak") "."))
(if (file? bak)
	(delete-file bak))
(rename-file sorgente bak)  
(write-file sorgente text)

(exit)

Sono una quarantina di righe ma quella fondamentale è (set 'text (lower-case text)). Proviamolo su un file di prova (prova), otteniamo

OK! perfetto 😀 O no?

Sì funziona ma c’è un fatto: “quando hai un buon martello tutto sembra un chiodo“. Forse si poteva fare con mezzi più semplici, con tools resi disponibili dal Sistema Operativo. Sì se fosse stato su Linux, nell’ambiente in cui mi trovavo (quello che spesso mostra una schermata blu con scritte bianche che ti dicono di prenderti una pausa mentre riavvii) no.

Tornato a casa non ho resistito, dovevo farlo 8)

La prima idea è stata di usare AWK, per ragioni storiche: tutte le volte che ne proponevo l’uso mi dicevano di no; adesso posso e allora (lc-awk.sh)

#!/bin/sh
cat $1 | awk '{print tolower($0)}'

testandolo si ha

OK! perfetto 😀 O no?

Si può fare di meglio: non c’è bisogno di AKW, basta bash (b.sh)

#!/bin/bash
tr '[A-Z]' '[a-z]' < $1

verifica

Volendo, si può essere ancora più eleganti (b1.sh)

#!/bin/bash
tr '[:upper:]' '[:lower:]' < $1

OOOK! 😀

Ci sarebbero moltissimi altri modi per ottenere lo stesso risultato, per esempio in Python c’è

str.lower()
Return a copy of the string converted to lowercase.

esattamente come in newLISP. Chi ha copiato?
Ma lo sapevamo di già

tutte le strade portano a Ankh-Morpork

E poi, a dirla proprio tutta-tutta, non sono nemmeno originale. Tempo fa avevo segnalato il link a “trying to use Unix tools“: dovrei fare più attenzione a quello che leggo e riporto.

________________
Poi per chi volesse approfondire sul 伟大舵手 può partire da qui, sì c’è anche in italiano.

Ancora sui numeri grossi, ma anche piccoli

A volte ritornano! Chi? Cosa? Quello che volete, quello che non vi aspettate; per esempio oggi torna l’argomento già trattato nel post “Numeri grossi“.

Anche se, pare, non sia un argomento interessante. Ma interessa me a allora… 8)
Ci metto anche una dritta su Unix/Linux che tanti giudicheranno banale e elementare ma metti che uno inizi adesso –come me 8). (Sì a volte dico bugie ma mi hanno insegnato che le bugie si possono dire a fin di bene 😉 ).

Il post precedente finiva con la constatazione che per numeri davvero grandi la rappresentazione normale è insufficiente, così

Propongo di fare come fanno i matematici e gli scienziati (e anche gli ing.): ricorriamo alla rappresentazione esponenziale: il numero mille viene scritto come 1e3, cioè 1*10³; il numero un miliardo diventa 1e9.

Facile e efficace vero? C’è da dire che non a tutti piace e c’è un’alternativa, più usata dalle persone sane di mente e normali, talmente comune che non ci accorgiamo nemmeno di usarla. Sto parlando dei prefissi di SI (Sistema internazionale di unità di misura).
Quando diciamo kilometro, milligrammo, ettolitro, nanometro e simili stiamo usando SI.
E quando diciamo che il disco fisso (hard disk) del nostro computer è di 200 gigabytes usiamo ‘quasi’ SI. Sì perché in questo caso il fattore di moltiplicazione non è 1000 ma 2¹⁰ = 1024, vedi qui.

Tornando al nostro problema vediamo di riciclare gli script Python e bash aggiornandoli a rappresentare i numeri anche in formato esponenziale.

Ormai siamo abituati a scrivere j1 3^50 e deve essere possibile continuare a farlo ma se scriviamo j1 -e 3^50 vogliamo la rappresentazione esponenziale.

Vediamo intanto come dobbiamo modificare lo script bash, propongo di chiamarlo jp1, eccolo

#!/bin/sh
par="calc "
xp=""

for c in $*
do
    if [ "$c" = "-e" ]; then
        xp="E"
    else
        par=$par\ $c
    fi
done

#echo $xp $par
./j30.py $xp `$par`

Semplice vero? Esegue un ciclo for per i parametri passati nella riga di comando ($*) accumulandoli nella variabile par ad eccezione di -e che viene memorizzato in xp.

Lo script di Python (adesso j30.py) viene anch’esso modificatto, così

#!/usr/bin/env python

import sys

#print sys.argv
if len(sys.argv) == 0:
    print 0
else:
    if sys.argv[1] == 'E':
        arg = sys.argv[2]
        xp = True
        fmt = '{:,e}'
    else:
        arg = sys.argv[1]
        xp = False
        fmt = '{:,}'
    try:
        if arg[0] == '~': arg = arg[1:]
        d = arg.find('.')
        if d >= 0:
            st = fmt.format(float(arg))
        else:
            st = fmt.format(long(arg))
    except:
        print 'error'
        sys.exit(1)

    if xp: d = st.find('.')
    p = st.find('.')
    if d >= 0:
        st = st[:p] + '@' + st[p+1:]
    q = st.find(',')
    while q > 0:
        st = st[:q] + '.' + st[q+1:]
        q = st.find(',')
    if d >= 0:
        st = st[:p] + ',' + st[p+1:]
    print st

Il formato di formattazione dell’istruzione format lo prendiamo sempre dalla documentazione online.

Entrambi gli script hanno un’istruzione commentata, (righe 14 e 5) molto utile in fase di debug. Per questo le ho lasciate, non si sa mai.

Notare come adesso la rappresentazione esponenziale sia utile anche per la rappresentazione di numeri molto piccoli, prossimi a zero, così

Ma non troppo piccoli

E abbiamo ancora un problema con i numeri negativi

perché il segno “–” viene interpretato come introduzione di un’opzione. Sarebbe da correggere, lasciato come compito per il lettore (compito delle vacanze). A meno che … No per adesso un altro post non è previsto 8)

Resta ancora un passo da fare: rendere il comando jp eseguibile indipendentemente dalla directory in cui ci troviamo, come i comandi seri ls, echo, cat…

Come qualcuno sa c’è una directory speciale nella nostra home, è la directory ~/bin. Il carattere “~” si ottiene con AltGr+ì con la tastiera italiana. Per vedere se c’è basta fare così

OK, io ho ~/bin e non ~/bon.

Se ~/bin è presente viene automaticamente inserita nella PATH, si può verificare con

Nel caso in cui non esista si può creare, così (N.B.: io creo ~/bon, per quando detto sopra)

A questo punto copiamo il file j30.py in ~/bin

Lo script jp1 dev’essere leggermente modificato, inoltre lo salvo come jp

#!/bin/sh
par="calc "
xp=""

for c in $*
do
    if [ "$c" = "-e" ]; then
        xp="E"
    else
        par=$par\ $c
    fi
done

#echo $xp $par
~/bin/j30.py $xp `$par`

e lo copio in ~/bin

D’ora in poi il comando sarà eseguibile da ogni directory

Attenzione: se avete creato la directory ~/bin questa sarà inserita nella PATH al prossimo avvio o reset. OK, ci sarebbe ancora qualcosa da dire ma per iniziare credo sia sufficiente.

_____________
Un piccolo aneddoto: mentre stavo preparando il post (in particolare lo script bash) sono incappato in uno di quegli errori banalissimi quando li fa un altro ma se lo fai tu e sei solo e ti intestardisci non lo trovi e dai di matto brutto.
Potenza di Google+: ho postato il problema e la soluzione è arrivata in pochi minuti, qui 8)

Un amico vale un tesoro, io ne avevo due online, di quelli tosti 8)

Numeri grossi

Quando i numeri superano un certo limite diventano difficili da comprendere, e anche da leggere.
Mi spiego: tutto è nato da una discussione sul Totocalcio (se ne parla anche quando non ci sono le partite, ah l’astinenza!). Abbiamo 13 pronostici ognuno con 3 opzioni quindi le combinazioni possibili sono 3 ^ 13, ossia

1594323, un milionecinquecentonovantaquattromilatrecentoventitrè.
Ecco scritto così è difficile da leggere, il secondo modo andrebbe bene, forse, per i tedeschi. Facciamo come i ragionieri: 1.594.323, OK 😀

E se poi mettessimo nella schedina più partite (in Brasile sono 15 (mi dicono)), per esempio anche tutta la serie B, diciamo 20 partite, allora abbiamo

no! illeggibile, dobbiamo fare qualcosa.

OK! in Unix (e nel suo successore Linux) c’è una grande tradizione di filtri, facciamone uno, propongo Python.

Con una googlata arriviamo a Format Specification Mini-Language

Ecco proprio quello che ci serve 8) O quasi: a differenza degli anglofoni usiamo il punto al posto della vergola e viceversa; ci serve uno scriptino.

Quello che vogliamo è un comando simile a calc ma che scriva i numeri in modo leggibile.

Dai è fattibile e semplice, qualcosa che faccia così:

Allora, secondo me dobbiamo coinvolgere calc, bash e Python. In alternativa, visto che calc deve essere installato e se non lo vogliamo potremmo sostituirlo con bc.

Questa è la componente in Python

#!/usr/bin/env python

import sys

if len(sys.argv) == 0:
	print 0
else:
	try:
		arg = sys.argv[1]
		d = arg.find('.')
		if d >= 0:
			st = '{:,}'.format(float(arg))
		else:
			st = '{:,}'.format(long(arg))
	except:
		print 'error'
		sys.exit(1)

	p = st.find('.')
	if d >= 0:
		st = st[:p] + '@' + st[p+1:]
	q = st.find(',')
	while q > 0:
		st = st[:q] + '.' + st[q+1:]
		q = st.find(',')
	if d >= 0:
		st = st[:p] + ',' + st[p+1:]
	print st

Semplice vero? Lo script si aspetta che calc (o bc) restituisca un numero (righe 5, 12 e 14). Siccome il parametro è una stringa verifica se c’è il separatore decimale (il punto); se c’è trasforma la stringa in float (il double del C) –riga 12– altrimenti in long (intero a precisione estesa) –riga 14.

A questo punto il nostro numero è rappresentato dalla stringa st.
Salva quindi la posizione del punto decimale (se c’è), riga 19. Se c’è sostituisce il punto con il carattere @ –righe 20 e 21. Esegue poi il ciclo di sostituzione delle virgole con punti –righe 22-25. E infine se c’era il punto iniziale mette una virgola in quella posizione –righe 26 e 27.
Scrive la stringa risultato –riga 28. Fatto.

Non ci resta che abilitarlo come comando, visto che abbiamo un terminale aperto lo facciamo con il comando

chmod +x j20.py

In alternativa in Nautilus click sul file j20.py con il tasto desto, selezionare Proprietà e poi Permessi e checkare (spuntare) “Consentire l’esecuzione del file come programma”

E bash? Beh, questo è facile, ne abbiamo parlato in passato, c’è il corso di Bit3Lux & Lightuono (lo state seguendo vero? adesso sono in ferie ma riprenderà), eccolo

./j20.py `calc $@`

Attiviamolo e proviamolo

Per chi volesse usare bc al posto di calc ecco jbc

./j20.py `echo $@|bc -l`

e abbiamo (dopo l’attivazione)

OK! credo che per oggi basti così. Ci sarabbero ancora altre cose da fare, prossimamente, forse 8)

Inoltre –nota personale– questo era quasi pronto ieri, solo che poi c’è stato nientepopodimenoche il terremoto

Io sono nel pallino rosso. L’epicentro è sulle montagne tra la Val Chisone (quella di Pinerolo) e la Val di Susa (quella della TAV). Niente danni, le nostre montagne sono di roccia e quella è la zona dov’è nata l’espressione “bugia nen“.

Ha spaventato solo la mia amica Giulietta

coraggio Giulia è passato 8)
Non credete ai giornali: fanno quello che fa la gente, per un paio di giorni c’è qualcosa su cui chiacchierare, oltre al tempo (stasera è previsto un temporale, comunque, per chi fosse interessato) 😉

Scorciatoie per il terminale

Non so voi ma a me capita spesso di usare il Terminale. A parte il fatto della nostàlgia –mi sembra di tornare ggiovane— in certi casi è indispensabile. Per esempio quando sto pythonando è estremamente comodo, dopo aver salvato il file in fase di sviluppo in Geany, andare sul terminale e digitare qualcosa come

pyhton t1.py uno due "tre quattro" cinque

Naturalmente il passo successivo il comando potrebbe variare e allora, dopo averlo richiamato con Up (freccia su) ci può essere l’esigenza di correggerlo. E qui entrano in gioco le scorciatoie che fanno risparmiare il numero di tasti premuti e il consumo degli stessi e dei polpastrelli 8)

Sì perché il terminale, o meglio la shell, dispone di un vero e proprio editor, con millantamila combinazioni. Ecco quelle che conosco, non le uso tutte (anzi qualcuna deriva da una sessione di googlate ad hoc per questo post).

Fondamentali
Alt Gr-ì
~ questo di sicuro la sanno tutti, altrimenti uno sarebbe costretto a scrivere continuamente /home/juhan (o peggio se non aveste avuto la fantastica idea di chiamare juhan il vostro user)

Alt Gr-‘
` backtick, usato in comandi complessi, sarebbe un discorso lungo e poi si può sostituire con $(), anzi è consigliato

Cancellazione
Crtl-U
cancella tutti i caratteri a sinistra del cursore

Ctrl-K
cancella tutti i caratteri dal cursore alla fine della riga

Ctrl-W
cancella la parola prima del cursore

Spostamenti del cursore
Ctrl-Up, Ctrl-A, Home
inizio della riga

Ctrl-Dn, Ctrl-E, Fine
fine della riga

Shift-PgUp
pagina precedente del terminale

Shift-PgDn
pagina successiva del terminale

Shift-Home
inizio del terminale –limitato dal buffer dello stesso

Shift-Fine
fine del terminale, cioè al prompt

Crtl-B
cursore a sinistra di un carattere

Crtl-F
cursore a destra di un carattere

Alt-B
cursore a sinistra di una parola

Alt-F
cursore a destra di una parola? no! menu File

Altri
Ctrl-L
clear<invio>, pulisce la finestra del terminale

Ctrl-C
chiusura (kill) del processo in corso di esecuzione

Ctrl-D
exit<invio>, termina il processo in corso nel terminale, se non ce n’è nessuno chiude il terminale (un processo in corso c’è, è sh)

Ctrl-R
richiama il comando nell’history; es.: per rifare un ping Ctrl-R e inizio a scrivere fino a quando mi propone quello giusto, ovviamente il cmd dev’essere nell’history

Ctrl-S
blocca il terminale, si sblocca con Ctrl-Q

Ctrl-T
scambia il carattere sotto il cursore con il precedente; il cursore avanza di uno

Crtl-{J, M, O}
<invio>

Alt-P
come Crtl-R ma senza msg e solo l’ultimo

Ctrl-Y
incolla il testo tagliato con Ctrl-U e Ctrl-K

Tab
completa il nome del file|directory, fin dove ci riesce

Shift-Ctrl-C
copia il testo evidenziato

Shift-Ctrl-V
pastaincolla il testo nel copiato con Shift-Ctrl-C
Da notare che il buffer di Ctrl-{U, K, Y} è diverso da quello di Ctrl-Shift-C. Quest’ultimo è quello di Ctrl-C nei programmi normali come browser, editor et similia.

E inoltre
^testo^NUOVO^ nell’ultimo comando (nell’history) sostituisce testo con NUOVO; a dire il vero non mi sembra granchè utile ma non si sa mai 😉

E per Windows?
Intanto lì il terminale si chiama Prompt dei comandi.

Ho provato con XP e la bella notizia è che potete tranquillamente dimenticare tutte queste scorciatoie: non ci sono 😀

Confessione
Tutto questo è nato dopo aver letto il post dell’amico Bit3Lux, qui.

Inizialmente pensavo di mettere solo un commento sul suo post poi ho cambiato idea e mi sento un pochino in colpa, come se mi fossi appropriato di una cosa non mia. Inoltre anche il trucchetto di ^^^ viene da lui, qui e sta ancora contnuando: sarebbe cosa buona e giusta seguire il suo blog.

Dite, se volete, che vi mando io.