Come Disinstallare Programmi su Ubuntu

Continuiamo la nostra rassegna di guide sull’utilizzo di Ubuntu e derivate ( Lubuntu e Kubuntu ) e vediamo in particolare come disinstallare un programma su Ubuntu. Capita, a volte, di aver installato un’ applicazione che, dopo poco, non si utilizza più e la si vuole rimuovere. Come fare? Niente di più facile: nelle prossime righe, ti illustreremo come disinstallare un programma su Ubuntu.

Come per la quasi totalità delle operazioni che si possono effettuare con Ubuntu, ci sono due strade possibili per disinstallare un programma: la prima tramite l’interfaccia grafica e la seconda con il terminale.

La prima strada è decisamente la più semplice ed immediata: avviamo Ubuntu Software Center che troviamo nella barra laterale e clicchiamo sulla scheda Installato. Da qui, cercheremo il programma che vogliamo rimuovere e potremo disinstallarlo premendo il bottone Rimuovi/Rimuovi Tutto. Per completare l’operazione, verrà richiesto di digitare la password del proprio account.

La seconda via che si può percorrere per disinstallare un programma su Ubuntu è quella di utilizzare il terminale. Apriamo quindi la nostra shell e prepariamoci a cercare manualmente il pacchetto software da disinstallare. Per eseguire questa operazione, dovremo digitare

sudo dpkg –list

Inseriamo la password del nostro account utente e potremo visualizzare la lista dei programmi presenti. Una volta individuato quello che vogliamo disinstallare, dovremo solamente digitare il seguente comando per rimuoverlo completamente dal sistema operativo:

sudo apt-get –purge remove [nome del pacchetto]

Digitiamo la nostra password e premiamo S per la rimozione del pacchetto software.

Quali Sono le Migliori Tastiere da Gaming Economiche

Per i videogiocatori più accaniti, le tastiere da gaming rappresentano uno di quei dettagli da non trascurare assolutamente poiché da essere dipenderà parte dell’esperienza di gioco che sarà possibile vivere in prima persona.

I modelli disponibili sul mercato si distinguono in base al prezzo ma anche, e soprattutto, in relazione alla praticità di utilizzo ed alle implementazioni software che potranno essere sfruttate grazie ad apposite scorciatoie, fruibili per mezzo di pulsanti dedicati o grazie ad una particolare combinazione di tasti.

Razer BlackWidow Chroma
La tastiera meccanica da gaming Razer è una delle più apprezzate dagli utenti, pur considerando la presenza di un layout statunitense (o eventualmente tedesco) a cui, dopo un po’ di pratica, ci si abitua facilmente: si tratta di un valido compromesso a fronte di prestazioni eccellenti.
La retroilluminazione può essere modificata tenendo conto di oltre 16.8 milioni di colori. Ottima la qualità costruttiva e la resistenza dei pulsanti, costruiti in maniera tale da reggere anche a tocchi più decisi.
Non mancano i tasti programmabili grazie ai quali accedere facilmente alla regolazione di tutti i vari parametri concernenti i giochi o qualunque altro tipo di contenuto multimediale.

Logitech G105
Questa tastiera da gaming si caratterizza per un livello di retroilluminazione tale da consentire un pratico utilizzo anche nelle ore notturne, potendone variare l’intensità in base al colore scelto.
I pulsanti programmabili danno modo di eseguire singoli comandi ed anche macro piuttosto complesse che prevedono una certa combinazioni di tasti.
Molto utile l’inserimento di un interruttore per attivare la modalità di gioco, disabilitando funzionalità del sistema operativo che potrebbero accidentalmente interrompere la sessione.

Perixx PX-1800
La tastiera da gaming economica che ci propone Perix è dotata di retroilluminazione policromatica (rosso, giallo e verde) e si connette al computer grazie al classico ingresso USB.
Abbiamo un layout italiano QWERTY ed il particolare design con cui è realizzato il prodotto ne rende l’utilizzo abbastanza ergonomico.
Disponibili 10 tasti di scelta rapida grazie ai quali sarà possibile regolare con estrema rapidità il livello dell’audio oppure le impostazioni relative al video, ma si potrà anche accedere istantaneamente a internet e molto altro ancora.

Come Fare Screenshot su Android

Avreste voluto salvare lo schermo del vostro smartphone Android quando avete stabilito il nuovo record al vostro gioco preferito ma non sapevate come fare? In questa guida, vi spiegheremo proprio come fare uno screenshot con Android.

Per screenshot, anche chiamato snapshot, si intende l’azione di catturare fotograficamente tutto ciò che è presente sullo schermo del nostro dispositivo in un dato momento. In pratica, stiamo facendo la fotografia istantanea della nostra attività, in questo specifico caso su smartphone Android.

Niente di più facile! Per fare uno screenshot con Android, su molti smartphone basterà semplicemente premere in contemporanea i tasti Power ( quello di accensione ) ed il tasto Home ( il tasto centrale sotto lo schermo ). Per altri dispositivi Android, invece, sarà necessario cambiare combinazione di tasti e pigiare: Power e volume giù. Quest’ultima sequenza è valida, ad esempio, per il Nexus 4.

Una volta che avremo scattato l’istantanea dello schermo del nostro smartphone Android vedremo un effetto uguale a quando utilizziamo normalmente la fotocamera del telefono e subito dopo visualizzeremo una notifica di salvataggio dello screenshot. Quest’ultimo sarà visibile nella galleria immagini, come qualsiasi altra fotografia fatta con il nostro dispositivo.

Alcuni smartphone di ultima generazione includono una funzione semplice ed intuitiva che permette di fare lo screenshot su Android semplicemente appoggiando il lato della mano sullo schermo del telefono e muovendolo da destra a sinistra o viceversa.

Esistono, poi, delle applicazioni scaricabili dal Play Store il cui scopo è quello di fotografare lo schermo del nostro Android.

Strutture Dati – Lo Stack

Ciao, oggi impareremo cosa è una struttura dati di tipo Stack, la sua implementazione con un Array in C, ed anche l’implementazione dinamica. Inoltre vedremo anche l’ambito di utilizzo.

Implementazione dello Stack usando gli Array

Uno Stack è una struttura dati che lavora sul principio LIFO (last in first out, ovvero l’ultimo ad entrare è il primo che esce).
Nel mondo informatico uno Stack può essere usato in molte applicazioni come ad esempio l’analisi della sintassi delle espressioni, nella gestione a run-time della memoria (usata nella Java virtual machine) e nell’intelligenza artificiale nella soluzione dei problemi tramite ricerca.

Operazioni sullo Stack

Push e pop sono le operazioni previste per l’inserimento e la rimozione di un elemento nello stack.

Codice per l’implementazione con Array

Di seguito il codice sorgente in C che mostra la struttura dati a Stack. Potete scaricarla e provarla sul vostro Pc.

Questo è l’header, salvatelo in un file chiamato “stack.h”

void push(int *s,int* top, int element);
int pop(int *s,int *top);
int full(int *top,const int size);
int empty(int *top);
void init(int *top);
Questa è l’implementazione dello stack, salvatela in un file chiamato “stack.c”

/*
initialize stack pointer
*/
void init(int *top)
{
*top = 0;
}

/*
push an element into stack
precondition: the stack is not full
*/
void push(int *s,int* top, int element)
{
s[(*top)++] = element;
}
/*
pop an element from stack
precondition: stack is not empty
*/
int pop(int *s,int *top)
{
return s[–(*top)];
}
/*
report stack is full nor not
return 1 if stack is full, otherwise return 0
*/
int full(int *top,const int size)
{
return *top == size ? 1 : 0;
}
/*
report a stack is empty or not
return 1 if the stack is empty, otherwise return 0
*/
int empty(int *top)
{
return *top == 0 ? 1 : 0;
}
Questo è il file di test, salvatelo come “teststack.c”

#include
#include
#include “stack.h”

#define size 3

void main()
{
int top,element;
int stack[size];

// initialize stack
init(&top);

// push elements into stack
while(!full(&top,size)){
element = rand();
printf(“push element %d into stack\n”,element);
push(stack,&top,element);
//press enter to push more
getchar();

}
printf(“stack is full\n”);

// pop elements from stack
while(!empty(&top)){
element = pop(stack,&top);
printf(“pop element %d from stack\n”,element);
//press enter to pop more
getchar();
}
printf(“stack is empty\n”);

getchar();
}

Implementazione Dinamica di uno Stack

Questa è un’altra versione di una struttura dati di tipo Stack. Con questa versione la dimensione dello Stack è dinamica e determinata a run-time.

Salvate il codice dell’header in un file chiamato “linkedstack.h”

int empty(struct node *s);
struct node* push(struct node *s,int data);
struct node* pop(struct node *s,int *data);
void init(struct node* s);
Salvate il codice della struttura dello stack dinamico nel file “linkedstack.c”

#include

struct node{
int data;
struct node* next;
};

void init(struct node* s){
s = NULL;
}

struct node* push(struct node* s,int data)
{
struct node* tmp = (struct node*)malloc(sizeof(struct node));
if(tmp == NULL){
// no memory available
exit(0);
}
tmp->data = data;
tmp->next = s;
s = tmp;
return s;
}
struct node* pop(struct node *s,int *element)
{
struct node* tmp = s;
*element = s->data;
s = s->next;
free(tmp);
return s;
}

int empty(struct node* s){
return s == NULL ? 1 : 0;
}
Ed infine il file per il test “testlinkedstack.c”

#include
#include

#include “linkedstack.h”

void main()
{
struct node* head = NULL;
int size,element,counter = 0;

/*
stack size is dynamic and
specified at runtime
*/
printf(“Enter stack size:”);
scanf(“%d”,&size);

printf(“Push elements to stack\n”);
init(head);
while(counter < size)
{
getchar();
element = rand();
printf(“push element %d into stack\n”,element);
head = push(head,element);
counter++;
}
printf(“Pop elements from stack\n”);
while(0 == empty(head))
{
head = pop(head,&element);
printf(“pop element %d from stack\n”,element);
getchar();
}

getchar();
}

Come Funzionano gli Altoparlanti

L’altoparlante può essere definito un trasduttore elettrico- acustico ( per trasduttore si intende genericamente qualsiasi dispositivo in grado di trasformare una forma di energia in un’altra); infatti esso provvede alla trasformazione dell’energia elettrica, disponibile all’uscita dell’amplificatore, in energia sonora.

Costruttivamente si compone di un cestello metallico rigido, che può avere forme diverse e che funziona da supporto per una membrana di materiale semirigido, chiamata cono. All’estremità del cono è fissata una bobina cilindrica, formata da poche spire di filo di rame, che prende il nome di bobina mobile ed i cui estremi fanno capo a due capicorda, fissati sul cestello ed isolati dallo stesso.

Quando la bobina mobile viene percorsa dalla corrente elettrica fornita da un amplificatore ( più avanti tratteremo il loro studio) si sposta avanti e indietro per effetto dell’azione reciproca fra il campo magnetico generato dalla corrente circolante nella bobina stessa ed il campo magnetico nel quale essa è immersa. La bobina è dunque alternativamente attratta e respinta dal magnete, al ritmo della frequenza della corrente e vibrando assialmente, fa muovere a sua volta il cono con il quale essa è solidale. Le vibrazioni del cono seguono quindi fedelmente l’andamento della corrente inviata nella bobina mobile e producono onde sonore ad essa corrispondenti.

Come qualsiasi componente elettrico ed elettronico, anche l’altoparlante è caratterizzato da alcune grandezze fondamentali, Potenza e Impedenza, che ne determinano l’impiego più idoneo in base a specifiche esigenze, come spiegato più nel dettaglio in questa guida sugli altoparlanti. La potenza nominale viene espressa in watt ed è in relazione alla massima potenza elettrica che può essere inviata in modo continuativo all’altoparlante.

L’impedenza deve essere adattata a quella dell’amplificatore che fornisce il segnale elettrico; essa è dovuta alle spire costituenti la bobina mobile e varia al variare della frequenza. Il valore dichiarato di impedenza, espresso in ohm, è riferito alle frequenze centrali della gamma acustica di 1000Hz o di 400Hz, i valori di impedenza più comuni sono compresi fra i 3 e 16 ohm.