Learning Programming for Beginners

One of the most frequently asked in Quora is : what are the websites which can help to learn programming online. To avoid answering the same questions again and again, I put the answer in this post, so whenever the same question popped up again, I will simply share the link as the answer.

Ok. Wanna learn coding online? Here is my recommendation list:

Lanjutkan membaca Learning Programming for Beginners

Weekly Photo Challenge: Nostalgic

This week’s challenge is Nostalgic. Every pictures that remind me of my home town is nostalgic to me. The place where I was born, grown up till senior high school, earning some money, struggle very hard to be the best student I could be, moving from one dormitory to another, must struggle to find a way just to survive one day, and moved to the big city, the city I live in now.

Here are some pictures that always remind me of my home town, to get the nostalgic feeling.

Utak Atik Gathuk – The Art of Coding – Sastra Pemrograman

Tadinya lagi baca milis Delphindo. Terus baca postingannya Kang Jaim, salah satu pendekar dalam dunia pemrograman. Iseng-iseng baca postingan dia, dan nemu yang ini.

 
Berikut tulisan beliau:
Tertarik dengan cuplikan kode yang ditulis pak budi, saya mencoba membuat implementasi serupa dengan menggunakan python, sebelumnya sebenarnya Waskita Adijarto telah mencoba memportingnya ke dalam bahasa C, dan sepertinya masih cukup panjang, kendati kode yang ditulisnya relatif lebih mudah dibaca.
 
Nah giliran daku juga penasaran, mencoba membuatnya dengan Java.
(Aku sendiri gak tahu ini kode untuk memecahkan masalah apa, yang menarik adalah bagaimana menuliskannya dalam berbagai bahasa pemrograman).
 
Berikut versi Perl (udah saya coba jalan dengan baik):
$m=4; $n=4;
for ($y=0; $y < $n ; $y++) { for ($x=0 ; $x < $m ; $x++) {
print $y*$m + $x . “:”;
if ($y!=0) { $neighbor = ($y-1) * $m + $x; print ” $neighbor “; } #N
if (!($x==($m-1))) { $neighbor = $y * $m + ($x + 1); print ” $neighbor “; } #E
if (!($y==($n-1))) { $neighbor = ($y+1) * $m + $x; print ” $neighbor “; } #S
if ($x!=0) { $neighbor = $y * $m + ($x – 1); print ” $neighbor “; } #W
print “n”; } }
 
Berikut versi C (belum dicoba karena saya gak punya compiler C, tapi saya yakin benar algoritmanya):
int main(int argc, char** argv) {     
int m = 4;     
int n = 4;     
int x, y;     
int neighbor;     
for (y = 0; y < n; y++) {         
for (x = 0; x < m; x++) {             
printf(“%d: “, y * m + x);             
if (y != 0) {                 
neighbor = (y – 1) * m + x;                 
printf(“%d “, neighbor);             
}// #N             
if (!(x == (m – 1))) {                 
neighbor = y * m + (x + 1);                 
printf(“%d “, neighbor);             
}; // } #E             
if (!(y == (n – 1))) {                 
neighbor = (y + 1) * m + x;                 
printf(“%d “, neighbor);             
}//#S            
if (x != 0) {                 
neighbor = y * m + (x – 1);                 
printf(“%d “, neighbor);             
}//#W            
printf(“n”);         
}     
}     
return (EXIT_SUCCESS); 
Berikut versi Python (saya coba kok error di kompie saya): 

#! /usr/bin/python
m, n = 5, 7
process = lambda x, y, z: z.append(y) if x else None

for i in range(m*n):
y, x = i / m, i % n
lst = []
process(y != 0, (y-1) * m + x, lst)
process((x!=(m-1)), y * m + (x + 1), lst)
process((y!=(n-1)),(y+1) * m + x, lst)
process((x != 0),y * m + (x – 1), lst)
print “%d: %s” % (i, ‘ ‘.join(str(key) for key in lst))

Nah yang terakhir saya buat versi Javanya:

public class HackingCode {
    public static void main(String[] args) {
        for (int m = 4, n = 4, y = 0; y < n; y++) {
            for (int x = 0; x < m; x++) {
                System.out.print((y * m + x) + ":");
                System.out.print((y != 0 ? " " + ((y - 1) * m + x)  : ""));
                System.out.print((x != m - 1 ? " " + (y * m + (x + 1)) : ""));
                System.out.print((y != n - 1 ? " " + ((y + 1) * m + x) : ""));
                System.out.print((x != 0 ? " " + (y * m + (x - 1)) : "") + "n");
            }         
        }            
    } 
}

Menurut Anda mana yang paling Anda sukai?

Mana yang paling mudah dimengerti?

Mana yang Anda pilih : lebih ringkas atau lebih readable?

Ada yang mau coba dalam bahasa lain?

Solusi untuk Danoe

Dapet email dari salah satu pembaca bukuku, Dari Pascal ke Java. Namanya Danoe. Berikut isi emailnya:

Salam mas wisnu….

Saya punya masalah dalam mengkonversi data masukan dari alat sensor
yang masuk ke komputer melalui port serial (COM1), data masukan berupa
array byte besarnya 4 byte (32 bit) dan ingin saya konversi menjadi
tipe data float atau double.

Saya menggunakan operator ternary untuk mendapatkan nilai 1 byte dari
array byte[] yang saya dapat dari port serial, kode :

public static byte satuByte(byte[] data) {
byte dataByte = (data == null || data.length == 0) ? 0x0 :
data[0];
return dataByte;
}

lalu saya mendapatkan keluaran range data dari 0, 1, 2, 3,…, 127,
-128, -127, -126,…, -3, -2, -1
yang merepresentasikan range data keluaran sensor yaitu 0 – 5 volt,
jadi ketika keluaran sensor 0 volt di komputer terbaca 0, ketika
keluaran sensor 2,4 volt di komputer terbaca 127, ketika keluaran
sensor 2,5 volt di komputer terbaca -128, dan ketika keluaran sensor 5
volt di komputer terbaca -1.(keluaran sensor saya ukur langsung
menggunakan alat multimeter/voltmeter)

Bisakah dengan range date byte (0, 1, 2, 3,…, 127, -128, -127,
-126,…, -3, -2, -1) berubah menjadi range data 0, 1, 2, 3,…, 253,
254, 255 di dalam java. Sehingga konversi ke range data sensor (0 – 5
volt) menjadi lebih mudah…karena waktu saya menggunakan delphi data
masukan dari port serial hanya terbaca 1 byte (8 bit) langsung tanpa
harus menggunakan operator ternary sehingga konversinya hanya
menggunakan kode berikut :

data = floattostr(dataSerial*(5/255));

dan data bisa langsung di tampilkan di layar konsol software…

output akhir yang di inginkan adalah kesamaan nilai antara nilai yang
tunjukan oleh alat ukur multimeter/voltmeter dengan output yang ada di
komputer…

best regards
danoe

=======================================================================

Saya bilang kepadanya, bahwa solusi itu sebenarnya cukup mudah. Tinggal lihat polanya saja bisa ketemu. Nah aku berharap Danoe sudah bisa menemukan caranya sebelum melihat postinganku ini.

Ayo dong, masak nyerah sih?

Ok, just in case sudah mentok, silakan lihat jawaban berikut, semoga menjawab pertanyaannya.

package conversion;

/**
*
* @author Wisnu Widiarta
*/
public class Main {

public static void main(String[] args) {
byte[] array = new byte[256];

for (int i=0; i<=127; i++) {
array[i] = (byte)i;
}
for (int i=128; i<256; i++) {
array[i] = (byte)(i – 256);
}
for (int i=0; i<256; i++) {
System.out.println(“Array[” + i + “] = ” + array[i] +
” dikonversi menjadi ” + convert(array[i]));
}
}

public static int convert(byte aByte) {
return (aByte >=0) && (aByte <= 127) ? aByte :
aByte + 256;

}

}

Output dari program ini adalah:

Array[0] = 0 dikonversi menjadi 0
Array[1] = 1 dikonversi menjadi 1
Array[2] = 2 dikonversi menjadi 2
Array[3] = 3 dikonversi menjadi 3
Array[4] = 4 dikonversi menjadi 4
Array[5] = 5 dikonversi menjadi 5
Array[6] = 6 dikonversi menjadi 6
Array[7] = 7 dikonversi menjadi 7
Array[8] = 8 dikonversi menjadi 8
Array[9] = 9 dikonversi menjadi 9
Array[10] = 10 dikonversi menjadi 10
Array[11] = 11 dikonversi menjadi 11
Array[12] = 12 dikonversi menjadi 12
Array[13] = 13 dikonversi menjadi 13
Array[14] = 14 dikonversi menjadi 14
Array[15] = 15 dikonversi menjadi 15
Array[16] = 16 dikonversi menjadi 16
Array[17] = 17 dikonversi menjadi 17
Array[18] = 18 dikonversi menjadi 18
Array[19] = 19 dikonversi menjadi 19
Array[20] = 20 dikonversi menjadi 20
Array[21] = 21 dikonversi menjadi 21
Array[22] = 22 dikonversi menjadi 22
Array[23] = 23 dikonversi menjadi 23
Array[24] = 24 dikonversi menjadi 24
Array[25] = 25 dikonversi menjadi 25
Array[26] = 26 dikonversi menjadi 26
Array[27] = 27 dikonversi menjadi 27
Array[28] = 28 dikonversi menjadi 28
Array[29] = 29 dikonversi menjadi 29
Array[30] = 30 dikonversi menjadi 30
Array[31] = 31 dikonversi menjadi 31
Array[32] = 32 dikonversi menjadi 32
Array[33] = 33 dikonversi menjadi 33
Array[34] = 34 dikonversi menjadi 34
Array[35] = 35 dikonversi menjadi 35
Array[36] = 36 dikonversi menjadi 36
Array[37] = 37 dikonversi menjadi 37
Array[38] = 38 dikonversi menjadi 38
Array[39] = 39 dikonversi menjadi 39
Array[40] = 40 dikonversi menjadi 40
Array[41] = 41 dikonversi menjadi 41
Array[42] = 42 dikonversi menjadi 42
Array[43] = 43 dikonversi menjadi 43
Array[44] = 44 dikonversi menjadi 44
Array[45] = 45 dikonversi menjadi 45
Array[46] = 46 dikonversi menjadi 46
Array[47] = 47 dikonversi menjadi 47
Array[48] = 48 dikonversi menjadi 48
Array[49] = 49 dikonversi menjadi 49
Array[50] = 50 dikonversi menjadi 50
Array[51] = 51 dikonversi menjadi 51
Array[52] = 52 dikonversi menjadi 52
Array[53] = 53 dikonversi menjadi 53
Array[54] = 54 dikonversi menjadi 54
Array[55] = 55 dikonversi menjadi 55
Array[56] = 56 dikonversi menjadi 56
Array[57] = 57 dikonversi menjadi 57
Array[58] = 58 dikonversi menjadi 58
Array[59] = 59 dikonversi menjadi 59
Array[60] = 60 dikonversi menjadi 60
Array[61] = 61 dikonversi menjadi 61
Array[62] = 62 dikonversi menjadi 62
Array[63] = 63 dikonversi menjadi 63
Array[64] = 64 dikonversi menjadi 64
Array[65] = 65 dikonversi menjadi 65
Array[66] = 66 dikonversi menjadi 66
Array[67] = 67 dikonversi menjadi 67
Array[68] = 68 dikonversi menjadi 68
Array[69] = 69 dikonversi menjadi 69
Array[70] = 70 dikonversi menjadi 70
Array[71] = 71 dikonversi menjadi 71
Array[72] = 72 dikonversi menjadi 72
Array[73] = 73 dikonversi menjadi 73
Array[74] = 74 dikonversi menjadi 74
Array[75] = 75 dikonversi menjadi 75
Array[76] = 76 dikonversi menjadi 76
Array[77] = 77 dikonversi menjadi 77
Array[78] = 78 dikonversi menjadi 78
Array[79] = 79 dikonversi menjadi 79
Array[80] = 80 dikonversi menjadi 80
Array[81] = 81 dikonversi menjadi 81
Array[82] = 82 dikonversi menjadi 82
Array[83] = 83 dikonversi menjadi 83
Array[84] = 84 dikonversi menjadi 84
Array[85] = 85 dikonversi menjadi 85
Array[86] = 86 dikonversi menjadi 86
Array[87] = 87 dikonversi menjadi 87
Array[88] = 88 dikonversi menjadi 88
Array[89] = 89 dikonversi menjadi 89
Array[90] = 90 dikonversi menjadi 90
Array[91] = 91 dikonversi menjadi 91
Array[92] = 92 dikonversi menjadi 92
Array[93] = 93 dikonversi menjadi 93
Array[94] = 94 dikonversi menjadi 94
Array[95] = 95 dikonversi menjadi 95
Array[96] = 96 dikonversi menjadi 96
Array[97] = 97 dikonversi menjadi 97
Array[98] = 98 dikonversi menjadi 98
Array[99] = 99 dikonversi menjadi 99
Array[100] = 100 dikonversi menjadi 100
Array[101] = 101 dikonversi menjadi 101
Array[102] = 102 dikonversi menjadi 102
Array[103] = 103 dikonversi menjadi 103
Array[104] = 104 dikonversi menjadi 104
Array[105] = 105 dikonversi menjadi 105
Array[106] = 106 dikonversi menjadi 106
Array[107] = 107 dikonversi menjadi 107
Array[108] = 108 dikonversi menjadi 108
Array[109] = 109 dikonversi menjadi 109
Array[110] = 110 dikonversi menjadi 110
Array[111] = 111 dikonversi menjadi 111
Array[112] = 112 dikonversi menjadi 112
Array[113] = 113 dikonversi menjadi 113
Array[114] = 114 dikonversi menjadi 114
Array[115] = 115 dikonversi menjadi 115
Array[116] = 116 dikonversi menjadi 116
Array[117] = 117 dikonversi menjadi 117
Array[118] = 118 dikonversi menjadi 118
Array[119] = 119 dikonversi menjadi 119
Array[120] = 120 dikonversi menjadi 120
Array[121] = 121 dikonversi menjadi 121
Array[122] = 122 dikonversi menjadi 122
Array[123] = 123 dikonversi menjadi 123
Array[124] = 124 dikonversi menjadi 124
Array[125] = 125 dikonversi menjadi 125
Array[126] = 126 dikonversi menjadi 126
Array[127] = 127 dikonversi menjadi 127
Array[128] = -128 dikonversi menjadi 128
Array[129] = -127 dikonversi menjadi 129
Array[130] = -126 dikonversi menjadi 130
Array[131] = -125 dikonversi menjadi 131
Array[132] = -124 dikonversi menjadi 132
Array[133] = -123 dikonversi menjadi 133
Array[134] = -122 dikonversi menjadi 134
Array[135] = -121 dikonversi menjadi 135
Array[136] = -120 dikonversi menjadi 136
Array[137] = -119 dikonversi menjadi 137
Array[138] = -118 dikonversi menjadi 138
Array[139] = -117 dikonversi menjadi 139
Array[140] = -116 dikonversi menjadi 140
Array[141] = -115 dikonversi menjadi 141
Array[142] = -114 dikonversi menjadi 142
Array[143] = -113 dikonversi menjadi 143
Array[144] = -112 dikonversi menjadi 144
Array[145] = -111 dikonversi menjadi 145
Array[146] = -110 dikonversi menjadi 146
Array[147] = -109 dikonversi menjadi 147
Array[148] = -108 dikonversi menjadi 148
Array[149] = -107 dikonversi menjadi 149
Array[150] = -106 dikonversi menjadi 150
Array[151] = -105 dikonversi menjadi 151
Array[152] = -104 dikonversi menjadi 152
Array[153] = -103 dikonversi menjadi 153
Array[154] = -102 dikonversi menjadi 154
Array[155] = -101 dikonversi menjadi 155
Array[156] = -100 dikonversi menjadi 156
Array[157] = -99 dikonversi menjadi 157
Array[158] = -98 dikonversi menjadi 158
Array[159] = -97 dikonversi menjadi 159
Array[160] = -96 dikonversi menjadi 160
Array[161] = -95 dikonversi menjadi 161
Array[162] = -94 dikonversi menjadi 162
Array[163] = -93 dikonversi menjadi 163
Array[164] = -92 dikonversi menjadi 164
Array[165] = -91 dikonversi menjadi 165
Array[166] = -90 dikonversi menjadi 166
Array[167] = -89 dikonversi menjadi 167
Array[168] = -88 dikonversi menjadi 168
Array[169] = -87 dikonversi menjadi 169
Array[170] = -86 dikonversi menjadi 170
Array[171] = -85 dikonversi menjadi 171
Array[172] = -84 dikonversi menjadi 172
Array[173] = -83 dikonversi menjadi 173
Array[174] = -82 dikonversi menjadi 174
Array[175] = -81 dikonversi menjadi 175
Array[176] = -80 dikonversi menjadi 176
Array[177] = -79 dikonversi menjadi 177
Array[178] = -78 dikonversi menjadi 178
Array[179] = -77 dikonversi menjadi 179
Array[180] = -76 dikonversi menjadi 180
Array[181] = -75 dikonversi menjadi 181
Array[182] = -74 dikonversi menjadi 182
Array[183] = -73 dikonversi menjadi 183
Array[184] = -72 dikonversi menjadi 184
Array[185] = -71 dikonversi menjadi 185
Array[186] = -70 dikonversi menjadi 186
Array[187] = -69 dikonversi men
jadi 187
Array[188] = -68 dikonversi menjadi 188
Array[189] = -67 dikonversi menjadi 189
Array[190] = -66 dikonversi menjadi 190
Array[191] = -65 dikonversi menjadi 191
Array[192] = -64 dikonversi menjadi 192
Array[193] = -63 dikonversi menjadi 193
Array[194] = -62 dikonversi menjadi 194
Array[195] = -61 dikonversi menjadi 195
Array[196] = -60 dikonversi menjadi 196
Array[197] = -59 dikonversi menjadi 197
Array[198] = -58 dikonversi menjadi 198
Array[199] = -57 dikonversi menjadi 199
Array[200] = -56 dikonversi menjadi 200
Array[201] = -55 dikonversi menjadi 201
Array[202] = -54 dikonversi menjadi 202
Array[203] = -53 dikonversi menjadi 203
Array[204] = -52 dikonversi menjadi 204
Array[205] = -51 dikonversi menjadi 205
Array[206] = -50 dikonversi menjadi 206
Array[207] = -49 dikonversi menjadi 207
Array[208] = -48 dikonversi menjadi 208
Array[209] = -47 dikonversi menjadi 209
Array[210] = -46 dikonversi menjadi 210
Array[211] = -45 dikonversi menjadi 211
Array[212] = -44 dikonversi menjadi 212
Array[213] = -43 dikonversi menjadi 213
Array[214] = -42 dikonversi menjadi 214
Array[215] = -41 dikonversi menjadi 215
Array[216] = -40 dikonversi menjadi 216
Array[217] = -39 dikonversi menjadi 217
Array[218] = -38 dikonversi menjadi 218
Array[219] = -37 dikonversi menjadi 219
Array[220] = -36 dikonversi menjadi 220
Array[221] = -35 dikonversi menjadi 221
Array[222] = -34 dikonversi menjadi 222
Array[223] = -33 dikonversi menjadi 223
Array[224] = -32 dikonversi menjadi 224
Array[225] = -31 dikonversi menjadi 225
Array[226] = -30 dikonversi menjadi 226
Array[227] = -29 dikonversi menjadi 227
Array[228] = -28 dikonversi menjadi 228
Array[229] = -27 dikonversi menjadi 229
Array[230] = -26 dikonversi menjadi 230
Array[231] = -25 dikonversi menjadi 231
Array[232] = -24 dikonversi menjadi 232
Array[233] = -23 dikonversi menjadi 233
Array[234] = -22 dikonversi menjadi 234
Array[235] = -21 dikonversi menjadi 235
Array[236] = -20 dikonversi menjadi 236
Array[237] = -19 dikonversi menjadi 237
Array[238] = -18 dikonversi menjadi 238
Array[239] = -17 dikonversi menjadi 239
Array[240] = -16 dikonversi menjadi 240
Array[241] = -15 dikonversi menjadi 241
Array[242] = -14 dikonversi menjadi 242
Array[243] = -13 dikonversi menjadi 243
Array[244] = -12 dikonversi menjadi 244
Array[245] = -11 dikonversi menjadi 245
Array[246] = -10 dikonversi menjadi 246
Array[247] = -9 dikonversi menjadi 247
Array[248] = -8 dikonversi menjadi 248
Array[249] = -7 dikonversi menjadi 249
Array[250] = -6 dikonversi menjadi 250
Array[251] = -5 dikonversi menjadi 251
Array[252] = -4 dikonversi menjadi 252
Array[253] = -3 dikonversi menjadi 253
Array[254] = -2 dikonversi menjadi 254
Array[255] = -1 dikonversi menjadi 255

 

Buku Dari Pascal ke Java Gratis!

Insya Allah minggu ini buku sudah siap terbit. Pantengin blog ini, karena sewaktu-waktu akan ada postingan official announcement terbitnya bukuku. 3 perespon pertama, bakalan dapat gratis. Untuk pemesanan, silakan join di milis http://groups.yahoo.com/group/pascal2java. Atau japri ke saya di multiply ini. Harganya insya Allah sekitar 50 ribu perak. Pembayaran transfer aja ke rekening BCA KCP Curug Kalimalang 2300706811. Oh ya dilengkapi CD lho. Jadi, pantengin terus yaa…

FizzBuzz Program

Barusan baca email di milis, tentang isi sebuah blog di sini. Dia bilang, dari 200 programmer pelamar suatu pekerjaan,
199 di antaranya gagal membuat sebuah program sederhana berikut ini:

Buat sebuah program yang menampilkan angka dari 1 hingga 100, dengan catatan jika angkanya kelipatan 3, maka tampilkan kata fizz ketimbang nulis angka itu sendiri, menulis kata buzz untuk kelipatan 5, dan fizzbuzz untuk kelipatan 3 dan 5. Sisanya menampilkan angka seperti apa adanya.

Pas aku baca blog itu, kebetulan ada 3 programmer pemula yang ada di sampingku, dan aku minta mereka membuat program tersebut. Dari ketiganya, 2 gagal total. Itupun yang bisa, masih ada sedikit sintaks error. Ini setidaknya membuktikan bahwa tidak semua programmer, bisa coding alias mrogram. Ada yang merasa sudah bisa memprogram,
namun mungkin kurang berlatih sehingga gagal mengerjakan
sebuah tugas yang sangat sederhana.

Iseng-iseng bikin versi program di atas dengan menggunakan beberapa bahasa:

Versi turbo prolog yang rekursif:

predicates
fizzbuzz(integer)
solution(integer)

clauses
fizzbuzz(I) :- I mod 15 = 0, write(“fizzbuzz”, “n”), !.
fizzbuzz(I) :- I mod 3 = 0, write(“fizz”, “n”), !.
fizzbuzz(I) :- I mod 5 = 0, write(“buzz”,”n”), !.
fizzbuzz(I) :- write(I, “n”), !.

solution(X) :-
X <= 100, fizzbuzz(X), Y = X + 1, solution(Y).

goal
solution(1).

Versi Pascal:

program FizzBuzz;

{$APPTYPE CONSOLE}

uses
SysUtils;

var
i: integer;
begin
for i := 1 to 100 do
begin
if i Mod 15 = 0 then
writeln(‘fizzbuzz’)
else if i Mod 3 = 0 then
writeln(‘fizz’)
else if i Mod 5 = 0 then
writeln(‘buzz’)
else
writeln(i);
end;

readln;

end.

Versi Java (dengan ternary operator ala C):

public class FizzBuzz {
public static void main(String[] args) {
for
(int i=1; i<=100; i++) {
System.out.println(i % 15 == 0 ? “fizzbuzz” : (i % 3 == 0 ? “fizz” : (i % 5 == 0 ? “buzz” : i)));
}
}
}

Di Microsoft Excel:
Bikin 2 kolom A1 diisi angka 1-100, kolom B1 sampai B100 diisi:
=(IF(MOD(A1;15)=0;”fizzbuzz”;(IF(MOD(A1;3)=0;”fizz”;(IF(MOD(A1;5)=0;”buzz”;A1))))))

Ada yang mau menambahkan dalam bahasa lain mungkin?

Cover Buku Pertamaku – Pascal ke Java

Kemarin pas ke Bandung untuk meeting di Buahbatu, ternyata penerbit yang akan menerbitkan bukuku hanya berjarak 2 rumah dari kantor tempat meeting. Pas ke sana, draft covernya sudah jadi. Dan idenya aku setuju. Doakan yah teman-teman dalam bulan Maret ini bukuku udah bisa terbit dan bisa tersedia di toko buku.

Buku ini berjudul Pascal ke Java, sebuah buku yang sifatnya tutorial dikhususkan buat mereka yang ingin belajar Java, dengan analogi dari bahasa Object Pascal. Java memang meminjam banyak sintaks dan operator dari C. Namun secara konsep pemrograman berorientasi Object, Java justru lebih dekat dengan Object Pascal. Mereka sama-sama tidak mendukung multiple inheritance, namun mendukung multiple interface.

Buku ini dilengkapi dengan contoh program yang dibuat dalam dua bahasa, yaitu Object Pascal dan Java. Dengan demikian, buat yang sudah mengerti Java dan akan belajar bahasa Object Pascal dengan IDE Borland Delphi, Turbo Delphi, atau bahkan Lazarus,
juga bisa dengan membaca buku ini.

Terima kasih diucapkan untuk Endy Muhardin, Rudi Hartono, dan Titus Budi, mereka adalah para programmer Java kawakan yang mau mereview isi buku ini.
Terima kasih pula untuk Mas Kusnasriyanto Totok, Delphi bangkotan, yang memperkenalkan saya dengan penerbit Informatika Bandung. Tentu saja yang tak kalah penting adalah Pak Beni dari penerbit, Mas Hendi sang perancang cover, Mas Rian dan Mas Ahmad yang membantu suntingan dan layoutnya.