Some things I've learnt about programming

මේක මම අද hacker news තුල සැරිසරද්දී කියවපු අපූරු ලිපියක්. මේක සිංහලට translate කරන්න කියල හිතුවත් එතකොට කියලා තියන එක වෙනස් වෙන්න පුලුවන් නිසා එහෙමම copy paste කලා :)

මේක ලියලා තියෙන්නේ අවුරුදු 30ක් field මේ එකේ xpernz තියන ඩයල් එකක්. ඒක නිසා තාමා මේ field එකේ අඳුරේ අතපත ගාන අපිට මේක ගොඩක් වැදගත් වෙයි කියලා හිතුවා

I didn't composed this but just copy pasted here. All the appreciations goes to John Graham
පහල link එක click කරලා original artical එක බලාගන්න පුලුවන්.

some things I've learnt about

"
I've been programming for over 30 years from machines that seem puny today (Z80 and 6502 based) to the latest kit using languages that range from BASIC, assembly language, C, C++ through Tcl, Perl, Lisp, ML, occam to arc, Ruby, Go and more.

The following is a list of things I've learnt.

0. Programming is a craft not science or engineering

Programming is much closer to a craft than a science or engineering discipline. It's a combination of skill and experience expressed through tools. The craftsman chooses specific tools (and sometimes makes their own) and learns to use them to create.

To my mind that's a craft. I think the best programmers are closer to watchmakers than bridge builders or physicists. Sure, it looks like it's science or engineering because of the application of logic and mathematics, but at its core it's taking tools in your hands (almost) and crafting something.

Given that it's a craft then it's not hard to see that experience matters, tools matter, intuition matters.

1. Honesty is the best policy

When writing code it's sometimes tempting to try stuff to see what works and get a program working without truly understanding what's happening. The classic example of this is an API call you decide to insert because, magically, it makes a bug go away; or a printf that's inserted that causes a program to stop crashing.

Both are examples of personal dishonesty. You have to ask yourself: "Do I understand why my program is doing X?". If you do not you'll run into trouble later on. It's the programmer's responsibility to know what's going on, because the computer will do precisely what it's told not what you wish it would do.

Honesty requires rigor. You have to be rigorous about ensuring that you know what your program does and why.

2. Simplify, simplify, simplify

Tony Hoare said: "There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies, and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult."

Simplify, refactor, delete.

I'd rephrase Hoare's maxim as "Inside every large, complex program is a small, elegant program that does the same thing, correctly".

Related to this is the 'small pieces loosely joined' philosophy. It's better to structure a program in small parts that communicate than to create some gigantic monolith. This is partly what has made UNIX successful.

3. Debuggers are sometimes a crutch, profilers are not

I almost never use a debugger. I make sure my programs produce log output and I make sure to know what my programs do. Most times I can figure out what's wrong with my code from the log file without recourse to a debugger.

The reason I don't use a debugger much is I think it leads to lazy thinking. Many people when faced with a bug reach for the debugger and dive into setting breakpoints and examining memory or variable values. It's easy to become enamored with such a powerful tool, but a little bit of thinking tends to go a long way. And if your program is so complex that you need a debugger you might need to go back to #2.

(Aside: having said all that, one of the programmers I most respect, John Ousterhout, seemed to spend all day in the Windows debugger).

On the other hand, profilers are essential if you need to understand performance. You'll never cease to be amazed what a profiler will tell you.

4. Code duplication will bite you

Don't Repeat Yourself. Do everything just once in your code.

This is related to #2, but is a special case. Even a simple piece of code that's duplicated will lead to trouble later when you 'fix' one version and forget about the other one.

5. Be promiscuous with languages

Some people get obsessed with a specific language and have to do everything in it. This is a mistake. There is not single greatest language for all tasks.

The key thing is to know which language in your toolbox you'll use for which problem. And it's best to have lots of tools. Try out different languages, build things in them.

For example, perhaps you'll not use Python or ML very much but you'll have played with list comprehensions and seen their power. Or you'll dabble in Go and will have seen how it handles concurrency. Or you'll have used Perl and seen the power of really flexible string handling. Or you'll have used PHP to quickly build a dynamic web page.

I hate language wars. They're basically for losers because you're arguing about the wrong thing. For example, in my hands PHP is a disaster, in the hands of others people make it sing. Similar things can be said about C++.

6. It's easier to grow software than build it

This is related to #2. Start small and grow out. If you are attacking a problem then it's easier to grow from a small part of the problem that you've tackled (perhaps having stubbed out or simulated missing parts) than to design a massive architecture up front.

When you create a massive architecture from the start you (a) get it wrong and (b) have created a Byzantine maze that you'll find hard to change. If, on the other hand, you work from small pieces that communicate with each other, refactoring will be easier when you realize you got it wrong from the start.

The root of this is that you never know what the truly correct architecture will look like. That's because it's very rare to know what the external stimuli of your program will be like. You may think that you know, say, the pattern of arriving TCP traffic that your mail server will handle, or the number of recipients, or you may not have heard of spam. Something will come along from outside to mess up your assumptions and if your assumptions have been cast into a large, interlocked, complex program you are in serious trouble.

7. Learn the layers

I think that having an understanding of what's happening in a program from the CPU up to the language you are using is important. It's important to understand the layers (be it in C understanding the code it's compiled to, or in Java understanding the JVM and how it operates).

It helps enormously when dealing with performance problems and also with debugging. On one memorable occasion I recall a customer sending my company a screenshot of a Windows 2000 crash that showed the state of a small bit of memory and the registers. Knowing the version of the program he had we were able to identify a null pointer problem and its root cause just from that report.

8. I'm not young enough to know everything

I've still got plenty to learn. There are languages I've barely touched and would like to (Erlang, Clojure). There are languages I dabble in but don't know well (JavaScript) and there are ideas that I barely understand (monads).

PS It's been pointed out that I haven't mentioned testing. I should have added that I do think that test suites are important for any code that's likely to be around for a while. Perhaps when I've been programming for another 30 years I'll have an answer to the question "Do unit tests improve software?". I've written code with and without extensive unit tests and I still don't quite to know the answer, although I lean towards unit tests make a difference.
"

හරිම අපූරුයි නුඹනම්

♥

දැනගතිමි මම
සසර පුරාවට මා පිං කර ඇති බව
සියල්ලට වැඩියෙන්
කෙතරම් වාසනාවන්තද වග
ලබන්නට කෙනෙක් නුඹවන්
අතිනත පටලවාගෙන ඇවිද යන්නට
ඉමක් නොපෙනෙන අනන්තය වෙත
පිරිමදින්නට නුඹේ නළලත
විඳින්නට ආදරය
නුඹ මා ලය මත

හොවාගෙන

♥

♥

 ♥   ♥                         ♥   ♥

♥              ♥             ♥             ♥
♥                        ♥                        ♥

♥                                                ♥

♥                                          ♥

♥                                   ♥

♥                            ♥

♥                   ♥

♥          ♥

♥

නුඹමයි

සොඳුරු මල් පිපෙන වසන්තය

රැගෙන ආවේ නුඹමයි

තෙලිතුඩින් ඇඳෙන්නේ නුඹේ සිතුවමමයි

පන්හිඳ ලියන කවියේ එලිසමය නුඹමයි

මා හදගැස්මේ රාවයත් දැන් නුඹමයි

මීදුම් දුමාරයේ

මීදුම් දුමාරයේ සීත හැන්ඳෑ යාමේ සිහින ඇන්ද සානුවේ
ආශා නැතිද මාත් එක් තනිව ඉන්න
කොළ පාට හැරුණු ඈත නිම්නයේ
කොළ පාට හැරුණු ඈත නිම්නයේ


නිශා නිම්න ඇහැරවා මල් බිඟුන්ටත් හොරා
ආශා නැතිද මාත් එක් තනිව ඉන්න
කොළ පාට හැරුණු ඈත නිම්නයේ
කොළ පාට හැරුණු ඈත නිම්නයේ


වලාවකින් හැඩදමා කූඩාරමක් එහි තනා
ආශා නැතිද මාත් එක් තනිව ඉන්න
කොළ පාට හැරුණු ඈත නිම්නයේ
කොළ පාට හැරුණු ඈත නිම්නයේ


මීදුම් දුමාරයේ සීත හැන්ඳෑ යාමේ සිහින ඇන්ද සානුවේ
ආශා නැතිද මාත් එක් තනිව ඉන්න
කොළ පාට හැරුණු ඈත නිම්නයේ

කොළ පාට හැරුණු ඈත නිම්නයේ

nodejs

මම අද කියලා දෙන්න යන්නේ අලුත්ම සීන්කෝන් එකක් ගැන. අලුත් කිවුවට ඉතින් මේක අලුත්මත් නෑ. හැබැයි ගොඩක් කස්ටියට මේක ගැන එච්චරම අවබෝධයක් නෑ (මටත් කියලා ඉතින් එහෙමම idea කියලා එකක් නෑ. මම try කරන්නේ මාත් ඉගෙනගනිමින් කස්ටියට කියලා දෙන්න.)
වැඩි බයිලා ඕනේ නෑනේ ඉතින්, මම කස්ටියට කියලා දෙන්න යන්නේ nodejs ගැන. සමහර කස්ටියට js කියන කෑල්ල දැක්ක ගමන් මීටර්වෙන්නැති මේක මොකක් හරි js සීන් එකක් කියලා (ඒ කියන්නේ javascript සීන් එකක් කියලා). කස්ටියට එහෙම හිතුනනම් හරි.

අපි දැන් බලමු මොකද්ද මේ nodejs කියන්නේ කියලා

කස්ටිය හැමෝම වගේ දන්නවා ඇති සාමාන‍ය්‍යයෙන් අපි javascript use කරන්නේ client side scripting වලට කියලා. ඒ කියන්නේ cleint ගේ පැත්තේ එහෙමත් නැත්නම් webbrowser එකේ validate කරන්න වගේ මොනවා හරි දෙයක් කරන්න. හැබැයි traditional javascript එහෙම උනාට nodejs අපි use කරන්නේ server side එකේ.
සරලවම කිවුවොත් nodejs කියලා කියන්නේ ගූගල් (Google) සමාගමේ ඉතා ජනප්‍රිය ( ඒ උනාට අම්බානේට memory කන ) Google chrome webbrowser එකේ javascript engine එක උඩ ඒ කියන්නේ v8 උඩ build කරපු javascript platform එකක්. (v8 javascript engine එක ගැන වැඩි විස්තර ඕනේ කස්ටියට මෙන්න මේ link v8 javascript engine එකට ගිහින් බලාගන්න පුලුවන් )
nodejs use කරන්නේ ඉතා පහසුවෙන්, වේගවත් ඒ වගේම පහසුවෙන් scale කරන්න පුලුවන් network application හදන්න. (Node.js is a platform built on Chrome's JavaScript runtime for easily building fast, scalable network applications)
nodejs වල use කරන්නේ event-driven කියන programming paradigm එක. ඒ කියන්නේ කාටත් තේරෙන සිංහලෙන්  කිව්වොත් program එකේ flow එක (program flow කියලා කියන්නේ program එක කොයි පිළිවලටද execute/run වෙන්නේ කියන එක) තීරණය වෙන්නේ සිද්ද වෙන event මත. ඒ වගේම nodejs use කරනවා දැන් අවුරුදු කීපයකට කලින් ජනප්‍රිය වෙච්ච  NIO එහෙමත් නැතිනම් Non-blocking IO කියන concept එක. මෙන්න මේ සීන් ටික නිසා nodejs පට්ට speed. ඒ නිසා eBay, Linkedin, Yahoo, Microsoft වගේ comapny වල realtime applications දැන් nodejs use කරනවා.

දැන් කස්ටියට නිකං නිදිමතයි වගේනම් අපි nodejs use කරගෙන හැමදාම කරනවා වගේ "හලෝ ලෝකය - Hello world" ගහලා බලමු.
අපිට nodejs run කරගන්න nodejs install ,text edit කරන්න පුලුවන් මොකක් හරි text editor එකකුයි, javascript  run වෙන මොකක් හරි webbrowser එකක් තියනවානම් වැඩිත් එක්ක.
nodejs installer එක කස්ටියට මෙන්න මේ nodejs installer link එකෙන් download කරගෙන install කරගන්න පුලුවන්.

එහෙම install කරගත්තට පස්සේ අපි environment variable path එක set කරගන්න එක ලේසියි. එහෙම නැතිනම් හැම තිස්සෙම nodejs install කරලා තියන location එක දෙන්න වෙනවා. path එක set එක දෙයක් ඇත්තෙම නෑ. java path එක set කරනවා වගේම තමයි. වෙනසකට තියෙන්නේ අපි path එක විදියට C:\Program Files\Java\jdk1.7.0_03\bin"" වෙනුවට දෙන්නේ අපෙ node js install කරල තියන floder location එක. මගේ machine එකේ විදියටනම් "C:\Program Files (x86)\nodejs" කියලා. (කස්ටියට path එක set කරන විදිය ගැන ideA එකක් නැත්නම් මම ජාවා වල path එක set කරන විදිය ගැන ලියලා තියන post එක බලන්න ---> How to set jdk path in windows 7 )

LOVE

ආසයි තුරුලටම වී ඉන්න නුඹගේ
සිප ගන්න නුඹේ ඔය උවනත
විඳගන්න ගතින් හමනා සුවඳ

මද සුළඟේ දඟ කරන 
නුඹේ ඔය කෙහෙරැලි ඇඟිලි තුඩින් පිරිමදිමින්
අතිනත පටලවාගෙන 
ඇවිදින්න ලෝකය පුරාවට

සිටින විට මගේ උරහිසේ නුඹේ හිස හොවාගෙන
මගේ ලය මත හිස තබාගෙන
ඕනෑ නොවේ කිසි දෙයක් මට නුඹ හැර
ආදරෙයි මම නුඹ හට සසර පුරාවට 

java - keywords (still under construction)

ජාවා keywords ගැන තමයි අද කතා කරන්නේ.
හරියටම keywords මෙච්චරක් තියනවා කියන්න විදියක් නෑ. හැබයි පොදුවේ ගත්තොත් keywords 50 -60 ත් (50 in Java 1.5) අතර ප්‍රමාණයක් තමයි තියෙන්නේ. පහල තියන list එකේ තියනවා keywords ටික. මෙතන ඔක්කොම keywords තියනවා කියන එක නම් මම gurantee කරන්නෑ.
මේ එකින් එක ගැන විස්තර කරන්න නම් අමාරුයි. මම කියන්නම් class වලට, methods  වලට හා වලට කරන්න පුලුවන් ගැන. පස්සේ වෙලාව තිබුනොත් අනික් ගැනත් ලියන්නම්

1. abstract
2. continue
3. for
4. new
5. switch
6. assert
7. default
8. goto
9. package
10. synchronized
11. boolean
12. do
13. if
14. private
15. this
16. break
17. double
18. implements
19. protected
20. throw
21. byte
22. else
23. import
24. public
25. throws
26. case
27. enum
28. instanceof
29. return
30. transient
31. catch
32. extends
33. int
34. short
35. try
36. char
37. final
38. interface
39. static
40. void
41. class
42. finally
43. long
44. strictfp
45. volatile
46. const
47. float
48. native
49. super
50. while

අපි මුලින්ම බලමු  class වලට use කරන්න පුලුවන් keywords මොනවාද කියලා.
එහෙම keywords 5ක් තියනවා
ඒ keywords 5 කොටස් දෙකකට බෙදන්න පුලුවන්.
1. access modifiers
2. non-access modifiers

access modifiers යටතේ තියෙන්නේ keywords දෙකයි.
public, default

non-access modifiersයටතේ තුනක් තියනවා
strictfp, final, abstract

public, default කියන keywords දෙක ගැනනම් ආයි කතාකරන්න ඕනේ නෑ. ඒ දෙක ගැන java - access modifiers http://alokayasoya.blogspot.com/#!/2012/01/java-access-modifiers.html එකේ ලියලා ඇති.

මුලින්ම බලමු strictfp කියන keyword එක ගැන. මේක classes වලට වගේම methods වලටත් use කරන්න පුලුවන්. මේ keyword එක use කලාම JVM එක floating point values handle කරන්නේ IEEE-754 floating-point specification එකට අදාලව තමයි.

Eyes wants to sleep

My eyes need to sleep coz it was so hard to looking at monitor for about 10 hours @ work and now @ home. But still heart wants to wait to see someone online

ලමැදේ හුස්මක් පවා

වැසිදාක තුරු යාය පීරා
අතුරාන පිණි සිත සීරා
දෑස හමුවේම උතුරාන දුටුවා එදා
හාද වී රෑ පුරා

ලමැදේ හුස්මක් පවා
ආලේ කලා ආසයි කියා

වැසිදාක තුරු යාය පීරා
අතුරාන පිණි සිත සීරා
ආයාචනා සීතේ ගලා
ආශා මවා මාගේ වෙලා
ආවා සිත දා පාවිලා
රෑ විලා.........
රෑ හීන පාසා වෑහේවි ආශා
මා හා....

ලමැදේ හුස්මක් පවා
ආලේ කලා ආසයි කියා

මේ චෝදනා දෑසේ පුරා
ආවා සොයා යායේ සරා
නාඩා දෑස හා
යාවෙනා
මේ හීන සේනා ආයේම ඕනා
මා හා.....

ලමැදේ හුස්මක් පවා
ආලේ කලා ආසයි කියා

සඳ පාන සඳ රේණු නාවා
හිත මාගේ සබකෝල වීලා
මගේ තුරුලේම
කොඳුරාන නොකියූ කතා
දෑස පියවී ගියා......

ලමැදේ හුස්මක් පවා
ආලේ කලා ආසයි කියා

Java - Simple console chat app

මෙන්න මචං මගේ ගානේ ජාවා වලට කැමති කට්ටියට සරල Chat application එකක්. කට්ටියට පොඩි පොඩි changes ටිකක් කරලා පට්ට chat එකක් හදා ගන්න මේක උදව්වක් වෙයි කියලා හිතනවා.
මෙන්න server එකේ code එක.

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author Thusitha
 */

public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(12345);
            while (true) {
                Socket incoming = serverSocket.accept();
                Runnable r = new ThreadedServer(incoming);
                Thread t = new Thread(r);
                t.start();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class ThreadedServer implements Runnable {
    private Socket incoming;
    private Scanner type = new Scanner(System.in);
    private Scanner reader;
    private PrintWriter writer;
    public ThreadedServer(Socket i) throws IOException {
        incoming = i;
        reader = new Scanner(incoming.getInputStream());
        new Thread(new Runnable() {
            public void run() {
                try {
                    InputStream inStream = incoming.getInputStream();
                    while (incoming.isConnected()) {
                        while (reader.hasNext()) {
                            System.out.println(reader.nextLine());
                        }
                    }
                } catch (IOException ex) {
                    Logger.getLogger(ThreadedServer.class.getName()).log(Level.SEVERE, null, ex);
                }
                try {
                    Thread.currentThread().sleep(1000);
                } catch (InterruptedException ex) {
                    Logger.getLogger(ThreadedServer.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }).start();
        new Thread(new Runnable() {
            public void run() {
                try {
                    OutputStream outStream = incoming.getOutputStream();
                    writer = new PrintWriter(outStream, true);
                    while (incoming.isConnected()) {
                        writer.println(type.nextLine());
                    }
                } catch (IOException ex) {
                    Logger.getLogger(ThreadedServer.class.getName()).log(Level.SEVERE, null, ex);
                }
                try {
                    Thread.currentThread().sleep(1000);
                } catch (InterruptedException ex) {
                    Logger.getLogger(ThreadedServer.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }).start();
    }
    public void run() {
    }
}
මුලින්ම මේ code එක notepad file එකට copy කරලා Server.java කියලා java file විදියට save කරගන්න. ඊට පස්සේ පහල තියන code එක වෙන notepad file එකකට  copy කරලා Client.java විදියට save කරගන්න. අන්තිමට files දෙකම compile කරගන්න.

මෙන්න client එකේ code එක.
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
*
* @author Thusitha
*/

class Client {
    private Scanner clientReader;
    private Socket s;
    private PrintWriter clientwriter;
    private Scanner clientType = new Scanner(System.in);
    public Client() {
        try {
            s = new Socket("localhost", 12345);
            clientReader = new Scanner(s.getInputStream());
            new Thread(new Runnable() {
                public void run() {
                    while (s.isConnected()) {
                        while (clientReader.hasNext()) {
                            System.out.println(clientReader.nextLine());
                        }
                    }
                    try {
                        Thread.currentThread().sleep(1000);
                    } catch (InterruptedException ex) {
                        Logger.getLogger(ThreadedServer.class.getName()).log(Level.SEVERE, null, ex);
                    }
                }
            }).start();
            new Thread(new Runnable() {
                public void run() {
                    try {
                        OutputStream outStream = s.getOutputStream();
                        clientwriter = new PrintWriter(outStream, true);
                        while (s.isConnected()) {
                            clientwriter.println(clientType.nextLine());
                        }
                    } catch (IOException ex) {
                        Logger.getLogger(ThreadedServer.class.getName()).log(Level.SEVERE, null, ex);
                    }
                    try {
                        Thread.currentThread().sleep(1000);
                    } catch (InterruptedException ex) {
                        Logger.getLogger(ThreadedServer.class.getName()).log(Level.SEVERE, null, ex);
                    }
                }
            }).start();
        } catch (UnknownHostException ex) {
            Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    public static void main(String[] args) throws Exception {
        new Client();
    }
}

දැන් අපිට මේක test කරන්න පුලුවන්. මුලින්ම Server.java file එක run කරන්න. ඊට පස්සේ අලුතෙන් command prompt එකක් open කරලා Client.java file එක run කරන්න. දැන් මොනවා හරි type (ටයිප්) කරලා Enter ඔබලා බලන්න. ටයිප් කරන ටික අනික් command prompt එකේ පේනවා.

එහෙනම් කට්ටියට ජය වේවා

Java - Simple Port Scanner

 අද මම කියලා දෙන්න යන්නේ ජාවා වලින් සරල පෝර්ට් ස්කෑනර් PORT SCANNER එකක් හදා ගන්න විදිය. (මම මේක හදලා තියෙන්නෙ ඔක්කොම port(පෝර්ට්) එ කියන්නේ port (පෝර්ට්) 65536 ම ස්කෑන් කරන්න විදියට. කැමති කට්ටිය ඕනේ විදියට වෙනස් කරගන්න. )
මුලින්ම පහල තියන code එක notepad එකට paste කරගන්න. ඊට පස්සේ ඒ ෆයිල් එක TestScanner.java කියලා save(සේව්) කරගන්න. File type(ෆයිල් ටයිප්) එක විදියට All Files දෙන්න.
ඊට පස්සේ ඒ ෆයිල් එක compile කරලා run කරන්න.ජාවා ෆයිල් එකක් compile කරලා run කරන විදිය මම කලින් එකක කියලා දුන්නා ;)(මොකක් හරි අවුලක් තියනවනම් අහන්න )

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

/**
*
* @author Thusitha
*/
public class TestScanner {

public static void main(String[] args) {
while (true) {
try {
System.out.println("Press 1 to find the IP Address of a host");
System.out.println("Press 2 to run the port scan");
System.out.println("Press 3 to exit");
BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in));
String command = consoleReader.readLine();
if (command.equalsIgnoreCase("1")) {
System.out.println("please enter hostname");
String hostName = consoleReader.readLine();
System.out.println("Trying to find the IPAddresses of " + hostName);
getIPAddress(hostName);
} else if (command.equalsIgnoreCase("2")) {
System.out.println("please enter hostname");
String hostName = consoleReader.readLine();
System.out.println("Trying to find the open ports in " + hostName + ". This make take several minutes");
portScan(hostName);
} else if (command.equalsIgnoreCase("3")) {
System.exit(0);
} else {
command = consoleReader.readLine();
}
} catch (IOException ex) {
ex.printStackTrace();
}
}

}

public static void portScan(String host) {
for (int i = 0; i < 65536; i++) {
try {
Socket socket = new Socket(host, i);
System.out.println("A server is listening on port " + i);
socket.close();
} catch (UnknownHostException ex) {
} catch (IOException ex) {
}
}
}

public static void getIPAddress(String host) throws UnknownHostException {
InetAddress[] hostAddress = InetAddress.getAllByName(host);
for (int i = 1; i < hostAddress.length; i++) {
System.out.println(hostAddress[i]);
}
}
}

මගේ හිත

ජීවිතේ හරිම පුදුමයි.
අපි හිතන්නේවත් නැති වෙලාවට
හිතන්නේවත් නැති විදියට
සමහරුන් අපේ හිතේ ලැඟුම් ගන්නවා.
ඔවුන් අපේ ජීවිතේ පුදුම විදියට වෙනස් කරනවා

එහෙම උනාම,
අනික් අය මොනවා කිවුවත්
තමන්ගේ හිතට දැනෙනදේ
කාටවත් ප්‍රතික්ෂේප කරන්න බෑ.

මොකද අපේ හිත දන්නවා
ඔවුන් අපේ ජීවිතයට කොතරම් වැදගත්ද කියන එක