Areca Backup

Areca adalah suatu backup software yang dapat dijalankan pada sistem operasi Windows ataupun Linux. Areca membuat copy-an backup (bisa dienkripsi dan dikompres) dari data Anda dan menyimpannya ke external drive, pendrive, FTP server, dan lain-lain.

Backup adalah membuat copy suatu data, sehingga hasil copy tersebut bisa digunakan untuk mengembalikan data yang original apabila terjadi kerusakan atau pun hilang.

Backup software adalah program dalam komputer yang digunakan untuk mem-backup suatu file, data, database, sistem, atau server. Backup software memungkinkan pengguna untuk menduplikasi segala sesuatu yang terkandung dari file asli. Software ini juga dapat digunakan untuk melakukan recovery data.

Recovery data adalah proses menyelamatkan data dari kerusakan, kegagalan, atau tidak dapat diakses media penyimpanan sekunder. Seringkali data terselamatkan dari media penyimpanan seperti hard disk drive, storage tapes, CD, DVD, RAID, dan elektronik lainnya. Pemulihan (recovery) mungkin diperlukan karena kerusakan fisik pada perangkat penyimpanan atau kerusakan logis pada sistem file yang mencegah dari tersusunnya oleh sistem operasi host.

Fitur-fitur umum yang biasanya ada dalam suatu backup software yang membuatnya lebih efektif dalam mem-backup suatu data:
- Volume
- Data compression
- Remote backup
- Access to open files
- Incremental backups
- Schedules
- Encryption
- Transaction mechanism

Areca adalah suatu backup software yang dapat dijalankan pada sistem operasi Windows ataupun Linux. Areca membuat copy-an backup (bisa dienkripsi dan dikompres) dari data Anda dan menyimpannya ke external drive, pendrive, FTP server, dan lain-lain.
Areca juga bisa melakukan perintah tambahan, seperti membuat report hasil backup ke harddrive, mengirimnya lewat email, menampilkan shell script sebelum atau sesudah backup.
Areca juga suport jenis backup incremental, differential, dan full.



Fitur-fitur yang dimiliki Areca
- Archives compression (Zip & Zip64 format)
- Archives encryption (algoritma enkripsi AES128 & AES256)
- Tempat penyimpanan di local hard drive, network drive, USB key, FTP / FTPs server (dengan implicit dan explicit SSL / TLS)
- Source file filters (by extension, subdirectory, regular expression, size, date, status, with AND/OR/NOT logical operators)
- Incremental, differential and full backup support
- Support for delta backup (store only modified parts of your files)
Archives merges : Dapat menggabungkan beberapa arsip menjadi satu arsip untuk menghemat kapasitas disk.
- As of date recovery : Memungkinkan untuk me-recovery arsip berdasar tanggal.
Transaction mechanism : Semua proses critical (seperti backup atau merging) adalah transaksional. Ini menjamin integritas hasil backup.
- Backup reports.
- Post backup scripts.
- Files permissions, symbolic links dan named pipes dapat di-store dan di-recovery. (hanya pada Linux)

Dengan fitur-fitur selengkap ini Anda dapat memperoleh software ini secara gratis di sini. ... (Klik untuk selengkapnya)

Undisker - Open, Create and Extract ISO Files

File ISO adalah file image, yaitu file yang mengandung duplikasi file-file suatu CD atau DVD yang dikemas dalam sebuah file. File ISO biasanya bermanfaat untuk menggandakan CD atau DVD atau juga bisa bermanfaat untuk membuat virtual drive pada komputer.

Virtual drive adalah semacam drive bayangan pada komputer, sehingga seakan-akan pada komputer terdapat drive tambahan.

Undisker adalah disk image utility yang tidak hanya bisa membuka dan membuat file ISO saja, akan tetapi software ini mampu mengekstrak file ISO tersebut secara langsung tanpa harus membuat virtual drive terlebih dahulu.

Undisker juga memungkinkan kita untuk membuat drive yang bootable. Saya pun menginstal Windows 7 dalam komputer saya lewat harddisk external dengan bantuan software ini.

Akan tetapi sangat disayangkan software ini tidak gratis. Anda perlu merogoh kocek Anda sebanyak €29.95 untuk mendapatkan versi full-nya. Bila tidak, Anda juga bisa meng-unduh versi trial-nya yang berlaku selama 30 hari di sini.

sumber:
http://www.undisker.com/ ... (Klik untuk selengkapnya)

Kamus Misuh Surabaya - Inggris (Repost, ngambil dari kaskus.us)

... (Klik untuk selengkapnya)

Queue dengan C++

Queue, kebalikan dari stack yang memiliki metode LIFO (Last in First Out). Dalam queue, metode yang digunakan adalah First In First Out (FIFO), dimana data yang masuk duluan maka akan terlebih dulu keluar. Contohnya seperti antrian nasabah bank, dimana nasabah yang pertama datang yang akan terlebih dahulu dilayani oleh teller. Di bawah ini adalah source code dari class queue.

Dalam source code di bawah ini data-data akan tersimpan dalam suatu circular array.
Circular array adalah array yang peng-index-annya seperti siklus yang berputar-putar. Ketika sudah mencapai index terakhir, pada increment selanjutnya akan kembali ke index awal.

Dalam penerapannya pada queue, terdapat variabel penyimpan index bernama front dan rear, yang menandakan data terdepan dan terbelakang dari suatu queue. Karena queue ini menggunakan circular, maka tidak selamanya front lebih kecil dari rear.

//--------------------------------------------------------//

#include "warga.h"

#define max 10

class queue
{
private:
int data[max];
int front, rear, count;
public:
queue();
bool isempty(); //penanda queue kosong
bool isfull(); //penanda queue penuh
int getfront(); //melihat index data terdepan
int getrear(); //melihat index data terbelakang
void enqueue(int data); //fungsi untuk memasukkan data ke dalam queue
warga dequeue(); fungsi untuk mengambil data dari queue
int getcount(); //melihat jumlah data yang ada dalam queue
~queue();
};

//Implementasi fungsi-fungsi dari class:

queue::queue()
{
front = -1;
rear = -1;
count = 0;
}

bool queue::isempty()
{
return (count == 0);
}

bool queue::isfull()
{
return (count >= max);
}

int queue::getfront()
{
return front;
}

int queue::getrear()
{
return rear;
}

void queue::enqueue(int data)
{
count++;
rear = (rear + 1) % max;
this->data[rear] = data;
}

int queue::dequeue()
{
count--;
front = (front + 1) % max;
return data[front];
}

int queue::getcount()
{
return count;
}

queue::~queue()
{
}

//--------------------------------------------------------// ... (Klik untuk selengkapnya)

Doubly Linked List dengan C++

Bedanya doubly linked list dengan singly linked list yaitu setiap node pada doubly linked memiliki pointer yang menunjuk ke node sebelumnya. Berbeda dengan singly linked list yang hanya punya pointer yang menuju ke node setelahnya. Berikut source code class doubly linked list.

//--------------------------------------------------------//


#include "iostream"

using namespace std;

class linkedlist
{
private:
struct node
{
int data;
node *next, *prev;
} *head, *tail;
public:
linkedlist();
bool isempty();
void addfirst(int data);
void addlast(int data);
void addafter(int data, int index);
void delfirst();
void dellast();
void del(int index);
int get(int index);
~linkedlist();
};

//Implementasi fungsi-fungsi dalam class:

#include "linkedlist.h"

linkedlist::linkedlist()
{
head = tail = NULL;
}

bool linkedlist::isempty()
{
return head == NULL;
}

void linkedlist::addfirst(int data)
{
node *baru = new node;
baru->data = data;
if(isempty())
{
head = tail = baru;
baru->next = baru->prev = NULL;
}
else
{
baru->next = head;
baru->prev = NULL;
head->prev = baru;
head = baru;
}
}

void linkedlist::addlast(int data)
{
node *baru = new node;
baru->data = data;
if(isempty())
{
head = tail = baru;
baru->next = baru->prev = NULL;
}
else
{
baru->prev = tail;
baru->next = NULL;
tail->next = baru;
tail = baru;
}
}

void linkedlist::addafter(int data, int index)
{
node *baru = new node, *temp = head;
baru->data = data;
for(int i = 0; i < index - 1 && temp->next != NULL; i++)
temp = temp->next;
baru->next = temp->next;
baru->prev = temp;
temp->next->prev = baru;
temp->next = baru;
}

void linkedlist::delfirst()
{
if(isempty()) return;
else if(head == tail)
{
head = NULL;
delete head;
return;
}
else
{
node *temp = head;
head = temp->next;
head->prev = NULL;
delete temp;
}
}

void linkedlist::dellast()
{
if(isempty()) return;
else if(head == tail)
{
delete head;
return;
}
else
{
node *temp = tail;
tail = temp->prev;
tail->next = NULL;
delete temp;
}
}

void linkedlist::del(int index)
{
if(isempty()) return;
node *temp = head;
for(int i = 0; i < index - 1 && temp->next != NULL; i++)
temp = temp->next;
node *temp2 = temp->prev;
temp2->next = temp->next;
temp->next->prev = temp2;
temp = NULL;
delete temp;
}

int linkedlist::get(int index)
{
if(isempty()) return -1;
node *temp = head;
for(int i = 0; i < index - 1 && temp->next != NULL; i++)
temp = temp->next;
return temp->data;
}

linkedlist::~linkedlist()
{
node *q;
q = head;
if(head == NULL) return;
while(q != NULL)
{
q = head->next;
delete head;
head = q;
}
}

//--------------------------------------------------------//

... (Klik untuk selengkapnya)

Stack dengan C++

Stack adalah struktur data yang menggunakan metode first in first out, yaitu data yang terakhir masuk yang keluar duluan. Contoh kasus stack misalnya dalam sebuah tumpukan piring. Ketika kita menumpukkan piring satu per satu hingga beberapa tumpukan, kemudian kita ingin mengambil piring dari tumpukan tersebut. Maka piring yang terambil pertama adalah piring yang terakhir kita letakkan dalam tumpukan. Berikut ini adalah source code stack menggunakan bahasa C++.

//--------------------------------------------------------//

#include "iostream"

#define max 10
using namespace std;

class stack
{
private:
int top;
int data[max];

public:
stack();
int gettop(); //untuk mengambil index data teratas/terakhir dari class stack
bool isfull(); //fungsi yang menandakan bahwa stack penuh
bool isempty(); //fungsi yang menandakan bahwa stack kosong
void push(int data); //perintah yang digunakan untuk memasukkan data ke dalam stack
int pop(); //perintah yang digunakan untuk mengambil data teratas dari stack
~stack();
};

//Implementasi fungsi-fungsi dalam class:

stack::stack()
{
top = -1;
}

int stack::gettop()
{
return top;
}

bool stack::isfull()
{
return (top >= max);
}

bool stack::isempty()
{
return (top == -1);
}

void stack::push(int data)
{
if(!(this->full()))
this->data[++top] = data;
}

int stack::pop()
{
return data[top--];
}

stack::~stack()
{
}

//--------------------------------------------------------//

Mudah bukan? hehe.. ... (Klik untuk selengkapnya)

Singly Linked List dengan C++

Berikut ini source code class linked list buatan saya.. B-)
Di sini tipe data yang digunakan adalah integer. Tipe data bisa diganti sesuai kebutuhan.

//--------------------------------------------------------//

#include "iostream"

using namespace std;

class linkedlist
{
private:
struct node
{
int data;
node *next;
} *head, *tail;
public:
linkedlist(); //constructor
bool isempty(); //cek kosongnya list
void addfirst(int data); //menambah data pada list dari awal
void addlast(int data); //menambah data pada list dari belakang
void addafter(int data, int index); //menambah data pada list setelah indeks yang ditentukan
void delfirst(); //menghapus data awal dari list
void dellast(); //menghapus data akhir dari list
void deletion(int index); //menghapus data indeks ke-n dari list
int get(int index); //mengambil data index ke-n tanpa menghapusnya
~linkedlist(); //destructor
};

//Implementasi fungsi-fungsi dalam class:

linkedlist::linkedlist()
{
head = tail = NULL;
}

bool linkedlist::isempty()
{
return head == NULL;
}

void linkedlist::addfirst(int data)
{
node *baru = new node;
baru->data = data;
if(isempty())
{
head = tail = baru;
baru->next = NULL;
}
else
{
baru->next = head;
head = baru;
}
}

void linkedlist::addlast(int data)
{
node *baru = new node;
baru->data = data;
if(isempty())
{
head = tail = baru;
baru->next = NULL;
}
else
{
tail->next = baru;
tail = baru;
tail->next = NULL;
}
}

void linkedlist::addafter(int data, int index)
{
node *baru = new node, *temp = head;
baru->data = data;
for(int i = 0; i <>next != NULL; i++)
temp = temp->next;
baru->next = temp->next;
temp->next = baru;
}

void linkedlist::delfirst()
{
node *temp = head;
if(isempty()) return;
else
{
head = temp->next;
temp = NULL;
delete temp;
}
}

void linkedlist::dellast()
{
node *temp = head;
if(isempty()) return;
else if(head == tail)
{
delete head;
return;
}
for(int i = 0; temp->next->next != NULL; i++)
temp = temp->next;
tail = temp;
temp->next = NULL;
delete temp->next;
}

void linkedlist::deletion(int index)
{
node *temp = head, *temp2;
if(isempty()) return;
for(int i = 0; i <>next != NULL; i++)
temp = temp->next;
temp2 = temp->next;
temp->next = temp->next->next;
temp2 = NULL;
delete temp2;
}

int linkedlist::get(int index)
{
node *temp = head;
if(isempty()) return -1;
for(int i = 0; i <>next != NULL; i++)
temp = temp->next;
return temp->data;
}

linkedlist::~linkedlist()
{
node *q;
q = head;
if(head == NULL) return;
while(q != NULL)
{
q = head->next;
delete head;
head = q;
}
}

//--------------------------------------------------------//

... (Klik untuk selengkapnya)