Dalam OOP terdapat 3 konsep dasar yaitu Encapsulation/Enkapsulasi, Polymorphisme dan Inheritance/Pewarisan. Ketiga konsep tersebut akan mempengaruhi seluruh program yang berorientasi pada object.

Misalnya terdapat kelas induk bernama Transformasi, berikut list programnya :

public abstract class Transformasi {
        int x=2;
        int y=4;
        public abstract void cetakTitikAsal();
}

Class Transformasi diatas merupakan Abstract Class yaitu class yang tidak dapat dibuat instancenya. Saat sebuah class ditandai sebagai abstract class, maka compiler akan menghentikan code apabila ada statement new diikuti nama class tersebut. Jika kita menandai class sebagai abstract class, maka kita tidak dapat membuat objek baru dari class tersebut, tetapi kita masih dapat menggunakan class tersebut sebagai tipe referensi yang dideklarasikan. Abstract class sebenarnya secara virtual no use, no value, no purpose in life, kecuali hanya untuk diperluas (is extended). Yang bekerja saat runtime adalah instance subclass dari abstract class.

Kemudian class Transformasi memiliki 3 class turunan yaitu class Dilatasi, class Refleksi dan class Translasi. Berikut list programnya:

Listing Program class Dilatasi

public class Dilatasi extends Transformasi {
       @Override
       public void cetakTitikAsal() {
       }
       public void hasilDilatasi(int k){
            System.out.println("Dilatasi oleh k menghasilkan titik ("+(k*x)+","+(k*y)+")");
       }
}

Listing Program class Refleksi

public class Refleksi extends Transformasi {
        int x=3;
        int y=-5;
        @Override
        public void cetakTitikAsal() {
             System.out.println("x = "+x+" dan y = "+y);
        }
        public void hasilRefleksi(){
        }
}

Listing Program class Translasi

public abstract class Translasi extends Transformasi {
        public abstract void hasilTranslasi();
}

Ketiga class diatas merupakan class turunan dari class Transformasi, ditandai dengan kata extends. Hal ini menggunakan konsep dasar Inheritance. Didalam Java inheritance berarti the subclass extends the superclass. Sebuah inhertance relationship berarti subclass mewarisi “the members of the superclass” (instance variables dan methods dari class tersebut).

Class Refleksi memiliki dua buah class turunan yaitu class RefleksiKeX dan class RefleksiKeY. Berikut list programnya :

Listing Program class RefleksiKeX

public class RefleksiKeX extends Refleksi {
        public void hasilRefleksi(int a){
        }
}

Listing Program class RefleksiKeY

public class RefleksiKeY extends Refleksi{
        public void hasilRefleksi (int b){
             System.out.println("Refleksi terhadap Y = "+b+" menghasilkan titik ("+x+","+(2*b-y)+")");
        }
}

Kedua class turunan diatas (class RefleksiKeX dan class RefleksiKeY) memiliki method yang mengoverriding dan mengoverloading method induknya yaitu class Refleksi. Overriding a method maksudnya adalah membuat method lain dengan nama, daftar argumen dan tipe kembalian yang sama, tetapi body method yang berbeda. Sedangkan overloading maksudnya adalah membuat method lain dengan nama yang sama tetapi memiliki daftar argumen yang berbeda.

Class Translasi juga memiliki 1 class turunan yaitu class TranslasiT. Berikut list programnya :

public class TranslasiT <strong>extends</strong> Translasi {
        public void hasilTranslasi(int a, int b){
             System.out.println("Translasi oleh T menghasilkan titik ("+(x+a)+","+(y+b)+")");
        }
        @Override
        public void hasilTranslasi() {
        }
        @Override
        public void cetakTitikAsal() {
        }
}

Class-class yang telah dibuat diatas dapat digunakan dengan membuat object yang menginstansiasi class yang digunakan. Sebelumnya class main dibuat terlebih dahulu dengan nama class TransformasiTestDrive. Berikut list programnya :

public class <strong>TransformasiTestDrive</strong> {
        public static void main(String[] args) {

             RefleksiKeX b1 = new RefleksiKeX();
             RefleksiKeY b2 = new RefleksiKeY();
             TranslasiT b3 = new TranslasiT();
             Dilatasi b4 = new Dilatasi();

             b1.<strong>cetakTitikAsal()</strong>;
             b2.<strong>hasilRefleksi(3)</strong>;
             b3.<strong>hasilTranslasi(-4, 5)</strong>;
             b4.<strong>hasilDilatasi(2)</strong>;
        }
}

Object yang dibuat adalah b1, b2, b3 dan b4. Masing-masing object akan menginstansiasi class dimana object tersebut dibuat. Object b1 akan menjalankan method cetakTitikAsal() yang diambil bukan dari class RefleksieX tetapi class Refleksi, karena method tersebut ada pada class Refleksi yang merupakan induk dari class RefleksiKeX.

Object b2 akan menjalankan method hasilRefleksi(3) dengan nilai argumen 3 yang merupakan method override dan overload dari class Refleksi.

Object b3 akan menjalankan method hasilTranslasi(-4, 5) dengan nilai argumen -4 dan 5 yang juga merupakan method yang telah dioverride dan dioverload dalam class TranslasiT.

Object b4 akan menjalankan method hasilDilatasi(2) dengan nilai argumen 2 yang terdapat dalam class Dilatasi.

Contoh Program JDBC

Koneksi Database Java Dengan MySQL

Dalam Java, untuk melakukan koneksi database dari java ke MySQL menggunakan JDBC. Sebelumnya kita harus meload atau mengaktifkan driver JDBC terlebih dahulu :

Class.forName("com.mysql.jdbc.Driver");

Class.forName("com.mysql.jdbc.Driver");

MySQLConnection.java

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;import java.util.logging.Level;
import java.util.logging.Logger;
/*
*To change this template, choose Tools | Templates
* and open the template in the editor.
*/
public class MySQLConnection {
        private String url = "jdbc:mysql://localhost:3306/sekolah";
        private String host = "localhost";
        private int port = 3306;
        private String username = "root";
        private String password = "vertrigo";
        private String database = "sekolah";
        private Connection conn = null;

        public MySQLConnection(){
        try {
             try {
                  Class.forName("com.mysql.jdbc.Driver").newInstance();
             } catch (InstantiationException ex) {
                  Logger.getLogger(MySQLConnection.class.getName()).log(Level.SEVERE, null, ex);
             } catch (IllegalAccessException ex) {
                  Logger.getLogger(MySQLConnection.class.getName()).log(Level.SEVERE, null, ex);
             }
         } catch (ClassNotFoundException ex) {
              Logger.getLogger(MySQLConnection.class.getName()).log(Level.SEVERE, null, ex);
         }
         }

         public Connection getConn() {
              if(conn==null){
                   try {
                        conn = DriverManager.getConnection(getUrl(), getUsername(), getPassword());
                   } catch (SQLException ex) {
                        Logger.getLogger(MySQLConnection.class.getName()).log(Level.SEVERE, null, ex);
                   }
              }
              return conn;
        }

        public void setConn(Connection conn) {
             this.conn = conn;
        }
        public String getDatabase() {
             return database;
        }
        public void setDatabase(String database) {
             this.database = database;
        }

        public String getHost() {
             return host;
        }

        public void setHost(String host) {
             this.host = host;
        }

        public String getPassword() {
             return password;
        }

        public void setPassword(String password) {
             this.password = password;
        }

        public int getPort() {
             return port;
        }

        public void setPort(int port) {
             this.port = port;
        }

        public String getUrl() {
             return url;
        }

        public void setUrl(String url) {
             this.url = url;
        }

        public String getUsername() {
             return username;
        }

        public void setUsername(String username) {
             this.username = username;
        }
}

Kemudian kita buat fungsi Main untuk mencoba koneksi

Misal : Test.java

import com.mysql.jdbc.Connection;
public class Test {
        public static void main(String[] args) {
             MySQLConnection msqlc = new MySQLConnection();
             Connection conn = null;
             msqlc.setUrl("jdbc:mysql://localhost:3306/sekolah");
             msqlc.setUsername("root");
             msqlc.setPassword("vertrigo");
             try {
                  msqlc.setConn(conn);
                  msqlc.getConn();
                  System.out.println("Koneksi Berhasil");
             } catch (Exception e) {
                  e.printStackTrace();
                  System.out.println("Koneksi Gagal");
             }
        }
}

Jika koneksi berhasil maka output yang dihasilkan adalah string koneksi berhasil, tetapi jika koneksi gagal maka outputnya adalah string koneksi gagal.

Contoh Program SERVLET

Dalam servlet terdapat dua class untuk melakukan response kepada user yaitu HttpResponse dan ServletResponse. ServletResponse merupakan class yang digunakan untuk mempresentasikan data kepada user. Method yang paling penting dalam class ServletResponse adalah getWriter() dengan method ini kita bisa memanggil object.java.io.PrintWriter yang bisa digunakan untuk menulis kode HTML atau text biasa.

Listing file index.html

< !DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd>
<html>
<head>
     <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
     <title>Send Request</title>
     </meta>
</head>
<body>
     <form action="Response" method="post">
          Author : <input type="text"/>
          <input type="submit" value="Submit"/>
     </form>
</body>
</html>

Listing class ResponseServlet

package com.insideservlet.servlet;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* Servlet implementation class for Servlet: ResponseServlet
*
*/
public class ResponseServlet extends javax.servlet.http.HttpServlet implements javax.servlet.Servlet {
        static final long serialVersionUID = 1L;
        /* (non-Java-doc)
        * @see javax.servlet.http.HttpServlet#HttpServlet()
        */
        public ResponseServlet() {
             super();
        }
        /* (non-Java-doc)
        * @see javax.servlet.http.HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
        */
        public void service(ServletRequest request, ServletResponse response) throws IOException{
             PrintWriter out = response.getWriter();
             out.println("<html>");
             out.println("<head>");
             out.println("<title>Servlet Response</title>");
             out.println("</head>");
             out.println("<body>");
             out.println("Server name : " + request.getServerName());
             out.println("Server port : " + request.getServerPort());
             out.println("Content Type : " + request.getContentType());
             out.println("Content Length : " + request.getContentLength());
             out.println("Protocol : " + request.getProtocol());
             out.println("Address : " +  request.getRemoteAddr());
             out.println("</body>");
             out.println("</html>");
        }
}

Kemudian konfigurasi web.xml diganti menjadi seperti program dibawah ini:

< ?xml version="1.0" encoding="UTF-8"?>
<web -app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<display -name>
InsideServlet</display>
<servlet>
<description>
</description>
<display -name>
ResponseServlet</display>
</servlet>
<servlet -name>ResponseServlet</servlet>
<servlet -class>
com.insideservlet.servlet.ResponseServlet</servlet>

<servlet -mapping>
</servlet><servlet -name>ResponseServlet</servlet>
<url -pattern>/Response</url>

<welcome -file-list>
</welcome><welcome -file>index.html</welcome>
<welcome -file-list>
</welcome></web>

Kemudian deploy program dan jalankan maka pada browser akan muncul output sebagai berikut :

Servlet ResponseServer name : localhost Server port : 8080 Content Type : application/x-www-from-urlencoded Content Length : 21 Protocol : HTTP/1.1 Address : 127.0.0.1

Contoh Program Gabungan OOP, JDBC, Servlet

Program dibawah merupakan program gabungan antara servlet, oop dan jdbc yang dapat digunakan sebagai poin awal dalam mengembangkan servlet-servlet lain yang berhubungan dengan database MySQL.

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.sql.*;
public class HelloWorldServlet extends HttpServlet {
        public void doGet (HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
             res.setContentType("text/html");
             ServletOutputStream out = res.getOutputStream();
             out.println("<html>");
             out.println("<head><title>Hello World</title></head>");
             out.println("<body>");
             try {
                  // The newInstance() call is a work around for some
                  // broken Java implementations
                  out.println("asdf");
                  Class.forName("org.gjt.mm.mysql.Driver").newInstance();
             }
             catch (Exception E) {
                  out.println("Unable to load driver.");
                  E.printStackTrace();
             }
             out.println("
<hr />");
             try {
                  Connection Conn = DriverManager.getConnection("jdbc:mysql://sql.useractive.com/USERNAME?user=USERNAME&password=PASSWORD");
                  // Do something with the Connection
                  Statement Stmt = Conn.createStatement();
                  ResultSet RS = Stmt.executeQuery("SELECT * from SOMETABLE");
                  while (RS.next()) {
                       out.println(RS.getString(1));
                  }
                  // Clean up after ourselves
                  RS.close();
                  Stmt.close();
                  Conn.close();
             }
             catch (SQLException E) {
                  out.println("SQLException: " + E.getMessage());
                  out.println("SQLState:     " + E.getSQLState());
                  out.println("VendorError:  " + E.getErrorCode());
             }
             out.println("
<h1>Hello World. Sun... 1.4</h1>
");
             out.println("</body></html>");
        }
        public String getServletInfo() {
             return "Create a page that says <i>Hello World</i> and send it back";
        }
}

Seminar ini dibagi menjadi 4 sesi :

1. Why FOSS?
   Oleh : Yudianto Sujana (STMIK Pelita Nusantara)
   Pada sesi ini akan dipaparkan gambaran umum tentang FOSS, keuntungan dan kerugiannya serta perangkat lunak yang termasuk dalam FOSS.
2. Introduction to Open Solaris
   Oleh : Alex Budiyanto (SUN Microsystem)
   Pada sesi ini akan dipaparkan terntang sistem operasi Open Solaris termasuk keunggulannya dibandingkan sistem operasi lain baik yang berbayar ataupun FOSS.
3. The Power of Java
   Oleh : Iesa Maliek (JUG-Joglosemar)
   Pada sesi ini akan dipaparkan tentang teknologi Java, kekuatan dan keunggulannya dibandingkan dengan teknologi lainnya.
4. Simplicity in Data Manipulation with MySQL
   Oleh : Theresia Herlina (STMIK Pelita Nusantara)
   Pada sesi ini akan dipaparkan kesederhanaan pengolah data dalam MySQL tanpa mengesampingkan kekuatannya.

Jadwal Kegiatan

• Tempat pelaksanaan : Pelita Convention Centre, STMIK Pelita Nusantara
• Alamat : Jl. C Simanjuntak No.99 Yogyakarta
• Tanggal, jam : 7 Februari 2009, 09.00 – selesai
• Pendaftaran : 29 Januari 2009 – 3 Februari 2009

Fasilitas

• Sertifikat
• Makan Siang
• Snack
• Souvenir (khusus yang telah bergabung di OSUM)
• Doorprize

Acara ini bersifat GRATIS dengan peserta terbatas

Untuk pendaftaran silahkan kirim email ke seminarfoss@pelitanusa.ac.id dengan menyebutkan nama, alamat, no telepon, email, institusi, atau bisa langsung datang ke STMIK Pelita Nusantara untuk mendapatkan tiket masuk.

Untuk informasi dapat menghubungi Esthi (085725033179) atau Yudi (08568598739)

Poster Seminar FOSS 2009

So, buruan daftar ya..sebelum kehabisan tempat..Oke, ditunggu ya emailnya..

Belajar MySQL 3

Menampilkan Data Dengan Perintah Select
Perintah ini digunakan untuk menyeleksi atau memilih atau menampilkan data-data yang terdapat di dalam tabel.

1. Menampilkan Semua Kolom

mysql> SELECT nim, nm_mhs FROM mahasiswa;
+---------+----------------+
| nim     | nm_mhs         |
+---------+----------------+
| 0601001 | Adi Kurniawan  |
| 0601002 | Esthi Budiasih |
| 0601003 | Hans Kristian  |
| 0601003 |                |
+---------+----------------+
4 rows in set (0.00 sec)

Sebenarnya kita bisa menampilkan data mahasiswa tidak harus urut, kita bisa juga mengacaknya sesui kebutuhan. Lihatlah contoh di bawah ini:

mysql> SELECT nm_mhs, nim FROM mahasiswa;
+----------------+---------+
| nm_mhs         | nim     |
+----------------+---------+
| Adi Kurniawan  | 0601001 |
| Esthi Budiasih | 0601002 |
| Hans Kristian  | 0601003 |
|                | 0601003 |
+----------------+---------+
4 rows in set (0.00 sec)

Contoh diatas kita harus menyebuutkan semua kolom yang ada pada tabel. Apabila kita ingn menyebutkan semua kolom tanpa harus menyebutkan nama kolom satu per satu, kita bisa menggunakan perintah seperti di bawah ini :

mysql> SELECT * FROM mahasiswa;
+---------+----------------+
| nim     | nm_mhs         |
+---------+----------------+
| 0601001 | Adi Kurniawan  |
| 0601002 | Esthi Budiasih |
| 0601003 | Hans Kristian  |
| 0601003 |                |
+---------+----------------+
4 rows in set (0.00 sec)

2. Menampilkan Sebagian Kolom
Misalnya kita akan menampilkan data hanya pada kolom nm_mhs saja pada tabel mahasiswa. Perintahnya sebagai berikut :

mysql> SELECT nm_mhs FROM mahasiswa;
+----------------+
| nm_mhs         |
+----------------+
| Adi Kurniawan  |
| Esthi Budiasih |
| Hans Kristian  |
|                |
+----------------+
4 rows in set (0.00 sec)

Sama seperti contoh perintah diatas. kita juga bisa menampilkan nm_mk saja pada tabel matkul.

mysql> SELECT nm_mk FROM matkul;
+------------------------------+
| nm_mk                        |
+------------------------------+
| Pengantar Teknik Informatika |
| Kalkulus 1                   |
| Algoritma Pemrograman        |
| Pengantar Manajemen          |
+------------------------------+
4 rows in set (0.00 sec)

3. Menampilkan Data Berkondisi Dengan Klausa WHERE
Dengan menggunakan parameter kondisi, kita dapat menampilkan beberapa baris data saja sesuai keinginan.

Untuk menuliskan kondisi, kita harus menuliskan klausa WHERE. Berikut ini contoh penggunaan dan latihannya.

a. Menampilkan Data mahasiswa yang memiliki nim 0601001 :

mysql> SELECT * FROM mahasiswa WHERE nim='0601001';
+---------+---------------+
| nim     | nm_mhs        |
+---------+---------------+
| 0601001 | Adi Kurniawan |
+---------+---------------+
1 row in set (0.00 sec)

b. Menampilkan data mahasiswa yang memiliki nama Esthi Budiasih :

mysql> SELECT * FROM mahasiswa WHERE nm_mhs='Esthi Budiasih';
+---------+----------------+
| nim     | nm_mhs         |
+---------+----------------+
| 0601002 | Esthi Budiasih |
+---------+----------------+
1 row in set (0.00 sec)

c. Menampilkan data matkul(kd_mk,nm_mk) yang memiliki data kode “TI0002″ :

mysql> SELECT kd_mk, nm_mk FROM matkul WHERE kd_mk='TI0002';
+--------+------------+
| kd_mk  | nm_mk      |
+--------+------------+
| TI0002 | Kalkulus 1 |
+--------+------------+
1 row in set (0.00 sec)

Perintah selanjutnya yaitu UPDATE akan kita bahas di waktu mendatang.
SELAMAT MENCOBA..!!

Data Manipulation Language adalah sub bahasa SQL yang berfungsi memanipulasi data yang ada di dalam database.
Perintah yang termasuk di dalam DML adalah INSERT, SELECT, UPDATE, DELETE.

Keempat perintah tersebut dapat digunakan setelah sistem database dan tabel terbentuk. Perintah-perintah tersebut hanya digunakan untuk mengelola data saja, sedangkan untuk membangun database dan strukturnya diperlukan perintah DDL.

Dalam kesempatan kali ini, kita akan belajar terlebih dahulu perintah INSERT, perintah-perintah yang lain akan dibahas pada pembahasan selanjutnya.

Dalam kasus ini misalnya kita membuat database sebuah kampus. Berikut penjabaran perintah2nya :

mysql> CREATE DATABASE IF NOT EXISTS kampus;
Query OK, 1 row affected (0.02 sec)

mysql> USE kampus;
Database changed

mysql> CREATE TABLE IF NOT EXISTS mahasiswa(
    -> nim CHAR(7) NOT NULL PRIMARY KEY,
    -> nm_mhs VARCHAR(30) NOT NULL
    -> );
Query OK, 0 rows affected (0.06 sec)

mysql> CREATE TABLE IF NOT EXISTS matkul(
    -> kd_mk VARCHAR(6) NOT NULL PRIMARY KEY,
    -> nm_mk VARCHAR(30) NOT NULL
    -> );
Query OK, 0 rows affected (0.06 sec)

Dari perintah-perintah diatas, pada database kampus telah terbentuk dua buah tabel, yaitu tabel mahasiswa dan matkul.
Berikut ini perintah untuk melihat tabel tersebut :

mysql> SHOW TABLES;
+------------------+
| Tables_in_kampus |
+------------------+
| mahasiswa        |
| matkul           |
+------------------+
2 rows in set (0.01 sec)

Untuk melihat deskripsi tabel mahasiswa, kita gunakan perintah berikut :

mysql> DESC mahasiswa;
+--------+-------------+------+-----+---------+-------+
| Field  | Type        | Null | Key | Default | Extra |
+--------+-------------+------+-----+---------+-------+
| nim    | char(7)     | NO   | PRI |         |       |
| nm_mhs | varchar(30) | NO   |     |         |       |
+--------+-------------+------+-----+---------+-------+
2 rows in set (0.00 sec)

Untuk melihat deskripsi tabel matkul, kita gunakan perintah berikut :

mysql> DESC matkul;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| kd_mk | varchar(6)  | NO   | PRI |         |       |
| nm_mk | varchar(30) | NO   |     |         |       |
+-------+-------------+------+-----+---------+-------+
2 rows in set (0.00 sec)

Menyimpan Data Dengan Perintah Insert
Perintah ini berfungsi untuk menyisipkan atau memasukkan atau meyimpan data dari luar sistem ke dalam database.Dalam penggunaannya, perintah INSERT memiliki bentuk beraneka ragam, berikut adalah bentuk implementasinya :

1. Memasukkan Data Dengan Menyamakan Kolom dan Data Kolom

mysql> INSERT INTO mahasiswa SET
    -> nim='0601001',
    -> nm_mhs='Adi Kurniawan';
Query OK, 1 row affected (0.03 sec)

Dengan cara diatas, didalam tabel mahasiswa sudah ada satu baris data.
Untuk memeriksa keberadaan data, gunakan perintah SELECT seperti contoh berikut :

mysql> SELECT * FROM mahasiswa;
+---------+---------------+
| nim     | nm_mhs        |
+---------+---------------+
| 0601001 | Adi Kurniawan |
+---------+---------------+
1 row in set (0.00 sec)

Dengan cara yang sama, kita bisa memasukkan data lengkap pada tabel matkul dengan perintah sebagai berikut :

mysql> INSERT INTO matkul SET
    -> kd_mk='TI0001',
    -> nm_mk='Pengantar Teknik Informatika';
Query OK, 1 row affected (0.00 sec)

Setelah perintah diatas dijalankan artinya kita sudah punya data baru di dalam tabel matkul

2. Memasukkan Data Dengan Menyebutkan Kolom

mysql> INSERT INTO mahasiswa(nim,nm_mhs)
    -> VALUES ('0601002','Esthi Budiasih');
Query OK, 1 row affected (0.00 sec)

Dengan perintah diatas kita sudah menambah satu baris data lagi ke dalam tabel mahasiswa.
Untuk melihatnya, kita gunakan perintah berikut :

mysql> SELECT * FROM mahasiswa;
+---------+----------------+
| nim     | nm_mhs         |
+---------+----------------+
| 0601001 | Adi Kurniawan  |
| 0601002 | Esthi Budiasih |
+---------+----------------+
2 rows in set (0.00 sec)

Berikut perintah yang sama untuk menambah satu data lagi ke dalam tabel matkul.

3. Memasukkan Data Tanpa Menyebutkan Kolom

mysql> INSERT INTO matkul(kd_mk,nm_mk)
    -> VALUES ('TI0002','Kalkulus 1');
Query OK, 1 row affected (0.00 sec)

Dengan cara diatas, didalam tabel mahasiswa akan terdapat 3 baris data. Untuk melihatnya, gunakan perintah berikut :

mysql> INSERT INTO mahasiswa VALUES ('0601003','Hans Kristian');
Query OK, 1 row affected (0.00 sec)
mysql> SELECT * FROM mahasiswa;
+---------+----------------+
| nim     | nm_mhs         |
+---------+----------------+
| 0601001 | Adi Kurniawan  |
| 0601002 | Esthi Budiasih |
| 0601003 | Hans Kristian  |
+---------+----------------+
3 rows in set (0.00 sec)

Dengan cara yang sama, kita bisa menambahkan pula data baru ke dalam tabel matkul.

mysql> INSERT INTO matkul VALUES ('TI0003','Algoritma Pemrograman');
Query OK, 1 row affected (0.00 sec)

4. Memasukkan Data Hanya Pada Sebagian Kolom

mysql> INSERT INTO mahasiswa (nim)
    -> VALUES ('0602001');
Query OK, 1 row affected, 1 warning (0.00 sec)

Dengan perintah diatas, kita hanya akan memasukkan data nim saja ke dalam tabel mahasiswa.
Untuk melihatnya, gunakan perintah berikut :

mysql> SELECT * FROM mahasiswa;
+---------+----------------+
| nim     | nm_mhs         |
+---------+----------------+
| 0601001 | Adi Kurniawan  |
| 0601002 | Esthi Budiasih |
| 0601003 | Hans Kristian  |
| 0602001 |                |
+---------+----------------+
4 rows in set (0.00 sec)

mysql> INSERT INTO matkul(kd_mk,nm_mk)
    -> VALUES
    -> ('SI0001','Pengantar Manajemen');
Query OK, 1 row affected (0.00 sec)

Cara lain untuk mengisi data sebagian kolom dengan mengosongkan data yang dimaksud dengan memberi tanda petik kosong seperti ini (‘ ‘).

Perintah selanjutnya yaitu SELECT akan kita bahas di waktu mendatang..
SELAMAT MENCOBA..!!

DDL singkatan dari Data Definition Language yang merupakan sub bahasa dari SQL dan berfungsi mendefinisikan database dan tabel. Perintah-perintah SQL yang digunakan antara lain : CREATE, ALTER, dan DROP. Apabila kita sudah bisa menggunakan ketiga perintah tersebut, berarti kita sudah bisa membangun struktur data dengan lengkap.

1. CREATE
Perintah CREATE yang digunakan berfungsi untuk membuat sebuah tabel beserta kolom (field)-nya. Berikut ini beberapa contoh perintah yang bisa digunakan sebagai media latihan :

mysql> CREATE DATABASE kampus;
Query OK, 1 row affected (0.00 sec)

Kemudian untuk mengaktifkannya gunakan perintah USE seperti contoh berikut :

mysql> USE kampus;
Database changed

Apabila kedua perintah diatas sudah dijalankan, berarti sekarang kita sudah berada di dalam database perusahaandb. Dan sekarang kita sudah bisa membuat sebuah tabel baru di dalam database aktif.

Berikutnya kita akan membuat sebuah tabel baru dalam database aktif. Sebelum kita membuat sebuah database baru, maka terlebih dahulu kita harus mengerti tabel apa yang akan kita buat nantinya dan bagaimana gambaran data yang akan disimpan di dalamnya. Berikut ini adalah contoh perintah dan hasilnya yang bisa kita coba bersama-sama :

mysql> CREATE TABLE mahasiswa(
    -> nim varchar(7),
    -> nama varchar(35)
    -> );
Query OK, 0 rows affected (0.00 sec)

Apabila setelah dieksekusi menghasilkan Query OK, berarti tabel berhasil dibuat, selanjutnya kita bisa mlihatnya dengan menggunakan perintah SHOW TABLES.

mysql> SHOW TABLES;
+------------------+
| Tables_in_kampus |
+------------------+
| mahasiswa        |
+------------------+
1 row in set (0.01 sec)

Pada tabel yang sudah kita buat, kita bisa melihat bentuk rancangannya dengan cara mendeskripsikannya. Perintah yang digunakan adalah DESC atau DESCRIBE. Berikut adalah contohnya :

mysql> DESC mahasiswa;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| nim   | varchar(7)  | YES  |     | NULL    |       |
| nama  | varchar(35) | YES  |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+
2 rows in set (0.00 sec)

Apabila kita sudah tidak memerlukan lagi tabel yang sudah pernah kita buat, maka kita dapat menghapus tabel tersebut dengan menggunakan perintah DROP. Berikut contoh penggunaan perintahnya :

mysql> DROP TABLE mahasiswa;
Query OK, 0 rows affected (0.00 sec)

Untuk membuktikan apakah tabel yang sudah kita hapus benar-benar terhapus atau belum, dapat kita lihat dengan menggunakan perintah SHOW TABLES.

mysql> SHOW TABLES;
Empty set (0.00 sec)

Dengan keluarnya pernyataan Empty set berarti perintah yang kita gunakan berhasil, karena sudah tidak ada tabel dalam database Kampus.
Selanjutnya kita dapat membuat tabel yang isinya tidak boleh kosong. Berikut contoh penggunaan perintahnya :

mysql> CREATE TABLE dosen(
    -> kd_dosen VARCHAR(3) NOT NULL,
    -> nm_dosen VARCHAR(35) NOT NULL,
    -> alamat_dosen VARCHAR(60) NOT NULL,
    -> telp_dosen VARCHAR(12)
    -> );
Query OK, 0 rows affected (0.01 sec)

Dengan perintah diatas struktur tabel yang kita buat akan tampak berbeda dari sebelumnya.

mysql> DESC dosen;
+--------------+-------------+------+-----+---------+-------+
| Field        | Type        | Null | Key | Default | Extra |
+--------------+-------------+------+-----+---------+-------+
| kd_dosen     | varchar(3)  | NO   |     | NULL    |       |
| nm_dosen     | varchar(35) | NO   |     | NULL    |       |
| alamat_dosen | varchar(60) | NO   |     | NULL    |       |
| telp_dosen   | varchar(12) | YES  |     | NULL    |       |
+--------------+-------------+------+-----+---------+-------+
4 rows in set (0.00 sec)

Kita juga bisa membuat PRIMARY KEY pada field akan kita buat. Berikut contoh penggunaan perintahnya :

mysql> CREATE TABLE mahasiswa(
    -> nim VARCHAR(7) NOT NULL PRIMARY KEY,
    -> nm_mhs VARCHAR(35) NOT NULL,
    -> alamat_mhs VARCHAR(60) NOT NULL,
    -> telp_mhs VARCHAR(12)
    -> );
Query OK, 0 rows affected (0.00 sec)

Dengan menambahkan kunci primer maka struktur tabel akan menjadi berbeda.

mysql> DESC mahasiswa;
+------------+-------------+------+-----+---------+-------+
| Field      | Type        | Null | Key | Default | Extra |
+------------+-------------+------+-----+---------+-------+
| nim        | varchar(7)  | NO   | PRI | NULL    |       |
| nm_mhs     | varchar(35) | NO   |     | NULL    |       |
| alamat_mhs | varchar(60) | NO   |     | NULL    |       |
| telp_mhs   | varchar(12) | YES  |     | NULL    |       |
+------------+-------------+------+-----+---------+-------+
4 rows in set (0.00 sec)

Untuk menghapus tabel yang sudah pernah kita buat, kita bisa menggunakan perintah DROP. Misalnya ada tabel dosen dalam database.

mysql> SHOW TABLES;
+------------------+
| Tables_in_kampus |
+------------------+
| dosen            |
| mahasiswa        |
+------------------+
2 rows in set (0.00 sec)
mysql> DROP TABLE mahasiswa;
Query OK, 0 rows affected (0.00 sec)

Apabila kita ingin membuat kunci primer sebagai kunci utama, kita tidak harus mendefinisikan parameter PRIMARY KEY pada satu baris yang sama, tetapi kita bisa mendefinisikannya di akhir perintah. Berikut contoh perintahnya :

mysql> CREATE TABLE dosen(
    -> kd_dosen int(3) NOT NULL,
    -> nm_dosen VARCHAR(35) NOT NULL,
    -> PRIMARY KEY(kd_dosen)
    -> );
Query OK, 0 rows affected (0.00 sec)

mysql> DESC dosen;
+----------+-------------+------+-----+---------+-----------+
| Field    | Type        | Null | Key | Default | Extra     |
+----------+-------------+------+-----+---------+-----------+
| kd_dosen | int(3)      | NO   | PRI | NULL    |           |
| nm_dosen | varchar(35) | NO   |     | NULL    |           |
+----------+-------------+------+-----+---------+-----------+
2 rows in set (0.00 sec)

2. ALTER
Perintah ALTER digunakan untuk mengubah struktur tabel yang telah dbuat. Misalnya kita akan menambah kolom baru dalam sebuah tabel, maka berikut contoh penggunaannya :

mysql> ALTER TABLE dosen ADD ktrangan TEXT
    -> AFTER nm_dosen;
Query OK, 0 rows affected (0.01 sec)

Perhatikan hasil penambahan kolom pada tabel dosen :

mysql> DESC dosen;
+----------+-------------+------+-----+---------+----------------+
| Field    | Type        | Null | Key | Default | Extra          |
+----------+-------------+------+-----+---------+----------------+
| kd_dosen | int(3)      | NO   | PRI | NULL    | auto_increment |
| nm_dosen | varchar(35) | NO   |     | NULL    |                |
| ktrangan | text        | YES  |     | NULL    |                |
+----------+-------------+------+-----+---------+----------------+
3 rows in set (0.00 sec)

Untuk menambahkan kunci primer dalam sebuah tabel misalnya kita buat dalam tabel mahasiswa, apabila ingin membuat tabel dosen yang baru, jangan lupa terlebih dahulu hapuslah tabel dosen yang sudah pernah dibuat. Berikut contoh penggunaan perintahnya :

mysql> DROP TABLE dosen;
Query OK, 0 rows affected (0.00 sec)

mysql> CREATE TABLE mahasiswa(
        -> nim VARCHAR(7) NOT NULL,
        -> nm_mhs VARCHAR(35) NOT NULL
        -> );
Query OK, 0 rows affected (0.00 sec)

Setelah membuat tabel baru dengan nama mahasiswa, untuk membuktikannya deskripsikanlah tabel tersebut seperti contoh dibawah ini :

 mysql> DESC mahasiswa;
+--------+-------------+------+-----+---------+-------+
| Field  | Type        | Null | Key | Default | Extra |
+--------+-------------+------+-----+---------+-------+
| nim    | varchar(7)  | NO   |     | NULL    |       |
| nm_mhs | varchar(35) | NO   |     | NULL    |       |
+--------+-------------+------+-----+---------+-------+
2 rows in set (0.00 sec)

Kemudian buatlah kolom kuncinya dengan perintah sebagai berikut :

mysql> ALTER TABLE mahasiswa
    -> ADD PRIMARY KEY(nim);
Query OK, 0 rows affected(0.01 sec)

Kemudian buktikanlah dengan perintah dibawah ini :

mysql> DESC mahasiswa;
+--------+-------------+------+-----+---------+-------+
| Field  | Type        | Null | Key | Default | Extra |
+--------+-------------+------+-----+---------+-------+
| nim    | varchar(7)  | NO   | PRI | NULL    |       |
| nm_mhs | varchar(35) | NO   |     | NULL    |       |
+--------+-------------+------+-----+---------+-------+
2 rows in set (0.00 sec)

Untuk mengubah nama kolom yang sudah kita buat dengan nama yang baru dapat dilakukan dengan perintah ALTER TABLE seperti dibawah ini :

mysql> ALTER TABLE mahasiswa CHANGE nm_mhs
    -> nama_mhs VARCHAR(50) NOT NULL;
Query OK, 0 rows affected(0.00 sec)

mysql> DESC mahasiswa;
+----------+-------------+------+-----+---------+-------+
| Field    | Type        | Null | Key | Default | Extra |
+----------+-------------+------+-----+---------+-------+
| nim      | varchar(7)  | NO   | PRI | NULL    |       |
| nama_mhs | varchar(50) | NO   |     | NULL    |       |
+----------+-------------+------+-----+---------+-------+
2 rows in set (0.00 sec)

Tabel yang sudah pernah kita buat juga bisa kita ganti namanya. Berikut contoh perintahnya :

mysql> SHOW TABLES;
+------------------+
| Tables_in_kampus |
+------------------+
| mahasiswa        |
+------------------+
1 row in set (0.00 sec)

mysql> ALTER TABLE mahasiswa RENAME TO mhs;
Query OK, 0 rows affected(0.00 sec)

mysql> SHOW TABLES;
+------------------+
| Tables_in_kampus |
+------------------+
| mhs              |
+------------------+
1 row in set (0.00 sec)

3. DROP

Kolom kunci yang sudah kita buat tadi dapat kita hapus dengan menggunakan perintah DROP. Untuk mengetahui lebih lanjut, cobalah perintah-perintah berikut ini :

Dalam hal ini kita akan menghapus kolom kunci dari tabel mhs.

mysql> ALTER TABLE mhs DROP PRIMARY KEY;
Query OK, 0 rows affected(0.00 sec)

mysql> DESC mhs;
+----------+-------------+------+-----+---------+-------+
| Field    | Type        | Null | Key | Default | Extra |
+----------+-------------+------+-----+---------+-------+
| nim      | varchar(7)  | NO   |     | NULL    |       |
| nama_mhs | varchar(50) | NO   |     | NULL    |       |
+----------+-------------+------+-----+---------+-------+
2 rows in set (0.00 sec)

Perintah dibawah ini digunakan untuk menghapus kolom(field) nama_mhs dari tabel mhs. Berikut adalah perintah dan hasilnya :

mysql> ALTER TABLE mhs DROP nama_mhs;
Query OK, 0 rows affected(0.00 sec)

mysql> DESC mhs;
+-------+------------+------+-----+---------+-------+
| Field | Type       | Null | Key | Default | Extra |
+-------+------------+------+-----+---------+-------+
| nim   | varchar(7) | NO   |     | NULL    |       |
+-------+------------+------+-----+---------+-------+
1 row in set (0.00 sec)

Untuk lebih jelasnya kita bisa melihat kembali daftar nama-nama database yang sudah pernah kita buat.

mysql> SHOW DATABASES

+--------------------+
| Database           |
+--------------------+
| information_schema |
| elektronikdb       |
| kampus             |
| latihan6db         |
| mysql              |
| perusahaandb       |
+--------------------+
6 rows in set (0.00 sec)

SELAMAT MENCOBA..!!

Linux adalah Sistem Operasi seperti UNIX, yang merupakan implementasi independen dari POSIX, meliputi true-multitasking, virtual memory, shared libraries, demand-loading, proper memory management, dan multiuser.

Sekarang Linux adalah sistem UNIX yang lengkap, bisa digunakan untuk jaringan (networking), pengembangan software, dan bahkan untuk sehari-hari. Linux sekarang merupakan alternatif OS yang jauh lebih murah jika dibandingkan dengan OS komersial, dengan kemampuan Linux yang setara bahkan lebih.

Linux seperti layaknya UNIX, mendukung banyak software mulai dari TEX, X Window, GNU C/C++ sampai ke TCP/IP.

Linux adalah sistem operasi yang disebarkan secara luas dengan gratis di bawah lisensi GNU General Public License (GPL), yang berarti juga source code Linux tersedia. Itulah yang membuat Linux bisa dibilang sangat spesial.

Linux masih dikembangkan oleh kelompok-kelompok tanpa dibayar, yang banyak dijumpai di Internet, tukar-menukar kode, melaporkan bug, dan membenahi segala masalah yang ada. Setiap orang yang tertarik dipersilahkan untuk bergabung dalam pengembangan Linux.

Linux pertama kali dibuat oleh Linus Torvalds di Universitas Helsinki, Finlandia. Kemudian Linux dikembangkan lagi dengan bantuan dari banyak programmer dan jagoan UNIX di Internet. Sekarang Linux bisa diperoleh dari distribusi-distribusi yang umum digunakan, misalnya RedHat, Debian, Slackware, Caldera, Stampede Linux, TurboLinux dan lain-lain. Kernel yang digunakan adalah sama-sama Linux, sedangkan perbedaannya hanyalah paket-paket aplikasi yang disertakan, sistem penyusunan direktori, init style, dll.

Mana yang lebih baik? Semua sama baiknya, tergantung selera. Jika diperdebatkan kelebihan dan kekurangan masing-masing, tidak akan pernah ada habisnya.

Linux dulunya adalah proyek hobi yang dikerjakan oleh Linus Torvalds yang memperoleh inspirasi dari Minix. Minix adalah sistem UNIX kecil yang dikembangkan oleh Andy Tanenbaum. Linux versi 0.01 dikerjakan sekitar bulan Agustus 1991. Kemudian pada bulan Oktober 1991 tanggal 5, Linus mengumumkan versi resmi Linux, yaitu 0.02 yang hanya dapat menjalankan bash (GNU Bourne Again Shell) dan gcc (GNU C Compiler).

• Mengapa pilih Linux??

1. Sejarah

Walaupun Linux bukanlah sistem Unix yang resmi, Linux mempunyai dasar warisan, budaya, arsitektur dan pengalaman operating sistem Unix selama 28 tahun lebih. Sejak munculnya Linux source code (tahun 1991) kernel Linux telah diteliti (review) dan disempurnakan oleh (minimal) puluhan ribu programmer di seluruh dunia. Sebagian besar program-program GNU dan X Window System telah ada lebih lama dari Linux dan telah diteliti lebih seksama.
Source code dari operating system saingan, seperti Windows 95 dan Windows NT, tidak tersedia untuk umum, sehingga tidak bisa diteliti oleh khalayak ramai. Desain dari sistem yang demikian tidak menikmati perkembangan sejarah dari sistem-sistem Unix.

2. Lisensi

Linux, sering juga disebut GNU/Linux, adalah operating sistem yang kompatible dengan Unix, berisi kernel Linux itu sendiri dan sekumpulan lengkap alat-alat dan program-program lain, yang kebanyakan di bawah naungan proyek GNU dari Free Software Foundation. Tampilan grafis atau Graphical User Interface (GUI) disediakan oleh X Window System beserta kumpulan libraries dan alat-alatnya.

Semua software ini bisa didapat gratis berdasarkan lisensi GNU General Public License atau lisensi-lisensi lain yang mirip dengan itu. Berdasarkan lisensi ini, siapa pun bisa mendapatkan program baik dalam bentuk source code (bisa dibaca manusia) mau pun binary (bisa dibaca mesin), sehingga program tersebut dapat diubah, diadaptasi, mau pun dikembangkan lebih lanjut oleh siapa saja.

Karena banyak sekali program-program maupun komponen software (biasanya tergabung dalam “paket”) yang membentuk sebuah sistem Linux yang lengkap, dan kesemuanya itu diurus oleh banyak orang dan organisasi dalam jadwal yang berbeda-beda, maka beberapa perusahaan dan organisasi mengumpulkan paket-paket tersebut menjadi satu distribusi (distro). Tapi tidak itu saja, mereka juga melakukan tes-tes terhadap software di dalamnya, mengembangkan program-program instalasi atau yang memudahkan instalasi, sebagian ada yang memberikan technical support, dan sebagainya. Ada distribusi komersial seperti Red Hat, Caldera, SuSE, dan ada juga distribusi yang non-komersial seperti Debian GNU/Linux. Baik distribusi komersial mau pun non-komersial tersedia tanpa dipungut biaya di internet, dan juga di media seperti CD-ROM (anda bayar ongkos media plus ongkos kirim tentunya). Perbedaan mendasar antara komersial dan non-komersial adalah bahwa produk komersial didukung oleh perusahaan yang menyediakan technical support, dan mungkin juga menyediakan beberapa software komersial lain yang tidak bisa didistribusikan secara gratis. Hal ini tentunya penting di lingkungan bisnis tertentu.

3. Pengguna

Linux diperkirakan mempunyai kurang lebih 7.500.000 pengguna, dan angka itu bertambah terus setiap harinya dengan sangat pesat.

4. Interaksi dengan OS lain

Linux bisa berinteraksi dengan operating sistem lain melalui tiga cara: kompatibilitas file dan filesystem, kompatibilitas network, dan emulasi (simulasi) operating sistem.

Linux bisa menggunakan file-file dari operating sistem lain, dalam artian bisa membaca dan menulis format file tersebut. Sehingga (hard)disk maupun disket-disket dari OS/2, NT, DOS/Windows, Apple Macintosh, Unix, dan sistem-sistem lain, bisa dibaca (dalam banyak hal juga ditulis) dengan mudah oleh Linux. Hampir semua format file standar industri didukung oleh aplikasi-aplikasi Linux, kecuali beberapa format yang spesifik vendor atau produk.

Di tingkat networking, Linux bisa bekerja sama dengan baik sekali dengan operating sistem lainnya. Linux mempunyai dukungan TCP/IP yang sangat bagus, dan juga mempunyai dukungan SMB untuk Microsoft file sharing and printing melalui paket Samba, Apple file and printer sharing lewat netatalk, dan IPX/SPX (Novell) file sharing lewat paket Mars NWE (dan paket komersial dari Caldera).

Dalam lingkungan campuran Windows/Linux, menggunakan Samba server dan sistem smbclient, komputer Linux akan tampil di Network Neighborhood dari sistem Windows, hampir tidak bisa dibedakan dengan NT. Komputer Linux juga akan mempunyai akses penuh ke file dan printer yang di-share dari WFWG, Windows 95, maupun Windows NT.

Emulasi operating sistem menyediakan kompatibilitas di lain sisi. Paket DOSEMU menyediakan kompatibilitas dengan DOS, dan proyek WINE menyediakan kompatibilitas (terbatas) dengan Windows. Ada juga paket emulasi komersial, yaitu Executor untuk emulasi Mac 680×0, dan WABI untuk emulasi 16-bit Windows 3.1.

5. Dukungan Hardware

Linux mendukung berbagai jenis perangkat keras PC, termasuk disk IDE, EIDE, SCSI, MFM, RLL, dan ESDI, tape dan CD-ROM drive SCSI dan EIDE, sound cards, berbagai jenis mouse, video cards, motherboard chipsets, scanners, printers, dan sebagainya. Hardware yang didukung oleh Linux mungkin tidak sebanyak Windows 95/98 tapi mungkin lebih banyak daripada Windows NT.

Beberapa vendor perangkat keras menyediakan driver secara langsung untuk Linux, beberapa menyediakan spesifikasi hardware secara cuma-cuma, dan selebihnya tidak menyediakan driver maupun spesifikasi untuk produk mereka. Tentu saja, produk-produk dari vendor yang menyediakan driver atau mengikuti aturan standar dari driver yang sudah ada mendapat dukungan utama, diikuti dengan produk-produk yang tersedia spesifikasi teknisnya (biasanya sebentar saja setelah spesifikasinya dipublikasikan) dan diminati oleh khalayak pengguna Linux, dan (relatif sedikit) produk-produk yang tidak ada informasi teknisnya biasanya tidak disupport.

6. Skalabilitas

Linux bisa berjalan di mesin sekecil 3Com Palm Pilot dan Digital Itsy dan mesin sebesar Beowulf clusters (sekumpulan PC yang cepat dihubungkan untuk menyelesaikan persoalan ilmiah/scientific).

Linux juga mendukung multiple processors hingga 16 buah.

7. Stabiltas

Sistem Linux sangat luar biasa stabil. Jika dikonfigurasi dengan benar, sistem Linux akan “hidup” terus hingga hardwarenya tidak memadai (rusak) atau tidak ada tegangan listrik atau seseorang mematikan sistem. Umur hidup sistem yang berkelanjutan hingga ratusan hari atau lebih merupakan hal yang sudah biasa. Penerjemah sering mendengar laporan dari user/network admin bahwa sistem Windows NT pada umumnya membutuhkan reboot berkala untuk menjaga stabilitas, dan Windows 95 yang pada umumnya perlu diinstall ulang supaya sistem bisa berjalan lancar tanpa keluhan.
Salah satu hal yang mendasari stabilitas ini adalah penomoran versi dari shared libraries. Kebanyakan aplikasi Windows menginstall versi-versi baru dari Dynamic Link Libraries(DLL), yang pada umumnya mengakibatkan aplikasi lain yang meminta versi lain dari DLL tersebut tidak berfungsi dengan semestinya. Lain halnya dengan shared libraries di Linux, yang mencantumkan versi pada nama filenya sehingga memungkinkan untuk menginstall versi barunya tanpa merusak ketergantungan program lain.

Linux juga mewarisi tradisi Unix dengan mendukung adanya file permissions (ijin file), yang dapat mencegah pengubahan atau penghapusan file tanpa ijin dari pemiliknya. Karena itu, virus pada dasarnya tidak dikenal di dunia Linux.

Masalah keamanan yang menyangkut operating system itu sendiri biasanya diumumkan beberapa jam saja setelah ditemukan, diikuti dengan bugfix, workaround, advisory, dan sebagainya. Misalnya waktu ditemukan bug di hardware itu sendiri (processor Pentium dengan bug F0 0F), workaround sudah tersedia untuk download beberapa saat setelah diumumkan adanya bug tersebut.

8. Pemanfaatan Memory

Virtual memory membuat Linux mempunyai kemampuan untuk menjalankan program-program yang lebih dari seharusnya jika hanya menggunakan memori fisik saja. Sistem virtual memory di Linux melebihi penggunaan sederhana dari swap space, program-program yang dijalankan lebih dari sekali akan dimasukkan sekali ke memori, dan sistem virtual memory akan digunakan untuk menggabungkan satu program image (text area) dengan banyak data images. Hal ini berakibat penggunaan memori yang optimal, namun demikian tetap memproteksi ruang memori dari masing-masing program, mencegah program saling “mengotori” ruang memori dari program lain.

9. Desain dan keamanan multiuser

Linux banyak mendasarkan diri pada Unix, sehingga salah satu keunggulannya adalah multi-user, sistem bisa digunakan oleh banyak orang secara bergantian maupun bersamaan (akses jarak jauh dari komputer atau terminal lain baik menggunakan modus teks maupun grafis seperti X Window).
File-file masing-masing user disimpan di ruang kerjanya (home directory) sendiri-sendiri, dan dilindungi dari pengubahan/penghapusan tanpa ijin dengan cara menerapkan kepemilikan dan perijinan file. Masing-masing program berjalan dengan ruang memorinya sendiri yang diproteksi oleh operating system sehingga tidak bisa mencampuri atau mengintip proses lain.

10. Kemudahan Akses Device

Device atau perangkat di Linux umumnya muncul sebagai file. Sehingga program-program bisa membaca dan menulis ke device-device seperti tape drive, modem, terminal, dan sebagainya.
Hal ini membuat hampir semua device bisa diakses oleh semua bahasa pemrograman, dengan meniadakan ketergantungan terhadap Application Programming Interfaces (API) yang spesifik dengan bahasa pemrograman tertentu. Di Windows, yang menggunakan model API, banyak perangkat yang hanya bisa diakses melalui C dan bahasa lain yang sejenis, dan membutuhkan program adapter (seperti OCX) untuk bisa diakses dari bahasa lain.

11. Scripting

Linux juga menyediakan berbagai peralatan scripting, yang memungkinkan anda untuk menulis “File .BAT dengan Steroids” untuk otomatisasi pekerjaan. Script-script ini bisa dijalankan secara manual, maupun dijadwalkan untuk waktu tertentu, bahkan bisa memiliki tampilan grafis (GUI).
Hampir semua informasi konfigurasi Linux disimpan dalam file-file teks yang membuatnya gampang diolah dengan script maupun secara manual. Hal ini memudahkan pekerjaan yang kompleks atau yang berulang-ulang, jika dibandingkan dengan sistem lain yang mempunyai sistem konfigurasi binary (seperti registry di Windows) dan juga sistem yang kurang mendukung scripting. Sebagai contoh, menambah beberapa ratus user yang datanya diambil dari (katakanlah..) spreadsheet, bisa dilakukan dengan mudah di Linux, tapi hampir tidak mungkin dilakukan di NT.

12.Penggunaan Network

Banyak bagian dari sistem Linux dibagi dua (client-server), dan keduanya bisa berjalan di komputer yang sama maupun berlainan.
Salah satu contohnya adalah GUI (Graphical User Interface) dari Linux yaitu X Window System. Hal ini memungkinkan aplikasi berjalan di komputer manapun di network, dan mengarahkan tampilan ke komputer manapun di network. Anda bisa menampilkan beberapa windows dari aplikasi secara bersamaan, satu windows dari aplikasi yang berjalan lokal di komputer anda, dan windows lain berasal dari aplikasi yang berjalan di komputer lain.

Contoh lain adalah pencatatan log dari printer, dan subsistem lainnya.
Kemampuan ini bisa berguna sekali untuk menyediakan technical support dan administrasi sistem jarak jauh. Malah, hampir semua operasi yang bisa dilakukan secara lokal bisa juga dilakukan dari jarak jauh lewat network, kecuali menyolokkan kabel atau menekan tombol power untuk menghidupkan komputer.

13. Banyaknya Service

Distribusi Linux pada umumnya sudah memiliki program-program networking beserta dokumentasinya. Hal ini tentu lebih baik jika dibandingkan dengan Windows NT, di mana banyak fasilitas seperti telnet, NFS, dan server X Window, tidak disertakan dalam distribusi standard dan biasanya harus dibeli terpisah dari perusahaan lain, dan tentu saja membutuhkan biaya lebih.

Contohnya, Linux bisa menerima banyak koneksi POP3 sekaligus dan kemudian meneruskannya ke sistem mail delivery standard. Hal ini belum memungkinkan di NT, bahkan dengan standard Exchange Server add-on.

14. Program-program (Aplikasi)

Aplikasi Linux berbeda dengan aplikasi Windows, tapi pada umumnya menyediakan fungsi yang sama. Dalam banyak hal, software gratis dan open-source di Linux menyediakan fungsi yang sama dengan aplikasi komersial yang lebih mahal. Contohnya, Gimp adalah program gratis yang berfungsi untuk pengolahan gambar yang bisa disetarakan dengan program komersial Adobe Photoshop yang bisa dibilan mahal.

Berbagai aplikasi komersial yang populer juga tersedia versi Linuxnya, antara lain Corel WordPerfect, Netscape FastTrack web server, Oracle, dan lain-lain. Banyak perusahaan yang sudah mulai menyediakan versi Linux untuk produk-produk unggulan mereka, dari Informix, Sybase, Corel, Allaire, dan lain-lain

15. Komunitas Pengguna

Salah satu kunci keunggulan Linux adalah komunitas penggunanya, yang memenangkan InfoWorld’s award for best support tahun 1997 mengungguli semua penyedia jasa technical support komersial. Red Hat Linux juga menerima penghargaan Product of the Year. Karena komunitas pengguna Linux meliputi komunitas developernya juga, maka sudah biasa kalau menerima respons atas pertanyaan kompleks yang ditanyakan di newsgroup comp.os.linux.misc hanya dalam waktu setengah jam atau paling lama satu hari. Mailing list juga merupakan forum di mana anda bisa mendapatkan respons yang lumayan cepat.

16. Alat-alat problem solving

Linux tidak menyembunyikan informasi dari user. Hal ini berarti informasi penuh dari keadaan sistem dan pesan kesalahan (error) selalu tersedia. Hal ini memungkinkan diagnostik masalah dengan cepat dan bisa diperbaiki dengan cepat pula.
Linux menyediakan alat-alat untuk menampilkan penggunaan memory dan CPU untuk masing-masing program, untuk menentukan program mana (kalau ada) yang menggunakan suatu file pada suatu saat, untuk melacak program pada saat berjalan, dan meneruskan pesan-pesan kesalahan (error) dari keseluruhan komputer di network ke satu komputer untuk memudahkan pengawasan (monitoring).

17. Support Komersial

Support komersial bisa didapatkan dari vendor distribusi komersial seperti Caldera atau Red Hat dan dari ratusan konsultan. Tidak seperti konsultan yang menyediakan jasa support untuk operating system proprietary yang mengandalkan bug fixes dan data-data teknis dari vendor atau perusahaan pemegang hak milik operating system tersebut, penyedia jasa support untuk Linux mempunyai akses penuh ke source code dan bisa menyelidiki masalah secara mendalam dan cepat. Mereka juga bisa mengubah program tersebut tanpa persetujuan dari penyedia software.

–>Kesimpulan

Linux menyediakan platform yang sangat maju dan stabil untuk berkomputer. Walaupun sejarah pengembangan dan sistem supportnya jauh berbeda dengan kebanyakan sistem operasi lain, Linux sangat menarik untuk digunakan di lingkungan bisnis, akademis, maupun pribadi.

Linux adalah pesaing berat dari Microsoft Windows. Keuntungan utama Linux terhadap Windows adalah pengembangan dan support secara terbuka, sejarah dan arsitektur Unix, serta stabilitasnya. Kekurangan utamanya berhubungan erat dengan lebih sedikitnya jumlah penggunanya: aplikasi yang tersedia belum sebanyak Windows, dan adanya selang waktu antara diperkenalkannya suatu hardware baru dengan supportnya di Linux. Linux memungkinkan penyesuaian dengan kebutuhan secara lebih jauh, dan berkurangnya ongkos pengelolaan administrasi jangka panjang, walaupun untuk memulai belajarnya relatif lebih sulit.
Linux sedang menuju puncak kejayaannya dan bisa menjadi perubahan yang hangat untuk pengguna yang sudah mulai jenuh dengan ketidakstabilan operating system lain.

SELAMAT MENCOBA LINUX..!!:)

Nb : tulisan ini berupa kutipan yang disadur dari beberapa sumber.