WHAT IS JAVA?

Java is a full-fledged programming language developed by Sun Corporation in 1991. It was originally designed to run on small electronic appliances such as set-top boxes (connecting your TV to a digital video server) or PDA's (personal digital assistants or hand-held computers). With the advent of the Web, Sun began to look at possibilities for integrating Java (then called "Oak") into Internet-delivered applications. "HotJava" was developed in 1994 (written in Java) as a sophisticated Web browser (for Unix computers) capable of running small programs called applets. Applets are written in Java and can be sent over the Web like HTML files to the browser, where they run in the a browser window, just like HTML documents. The startling thing about HotJava when it was released was the fact that what was displayed in the browser window using applets was not just static text and graphics, as with HTML pages, but dynamic elements such as scrolling text and animations. This was the first step in a radical shift in the computing world, one which is likely to affect education profoundly. For the first time there seems to be through Java an obtainable visions of user-friendly, platform-independent programs delivered over a network. Java holds the promise of being, in effect, a cross-platform operating system. It comes as little surprise that both Apple and Microsoft have hitched their wagons to the Java locomotive, announcing plans to incorporate Java into their respective operating systems.

In fact, Java, faithful to its roots, has the potential to run not just on desktop computers but on a variety of other microprocessor-driven devices. JavaOS, for example, is a version of Java developed to run on PDA's. How is this possible? Java, in comparison to other programming languages, is small, efficient, and versatile. Its versatility lies not only in the great variety of programs it can be used to create, but also in the fact that it is easily transportable from one environment or operating system to another. Traditional programming languages like C or C++ (the most popular languages in use today) require developers to create different versions of their programs for the respective operating systems they will be running under. Much of the original computer code in C can be re-used, but a new version must be compiled (translated into executable machine code) for each operating system. No one would expect a version of WordPerfect for Macintosh to run on a Windows computer. In contrast, Java programs need only be compiled once for all operating systems. This is because for each platform a specific Java interpreter (called a "virtual machine") runs the Java program. In other words, there is currently a kind of translator which sits between your Java programs and your computer's operating system. With system-level integration of Java, this go-between will in the future no longer be needed. Java is already built into IBM's OS/2 operating system.

One caveat to the "write once, run everywhere" nature of Java is Microsoft's approach of tying its implementation of Java tightly to the Windows operating system. The idea is to optimize Java performance and features for Windows users. This approach leaves out in the cold uers of other main-stream operating systems such as Macintosh and Unix, but more troublesome to my mind is that it subverts the promise of running a universal set of applications written in Java on new electonic devices like hand-held computers or TV set-top boxes (unless they, too, are running Windows). As we try to narrow the gap between the technology haves and have-nots, small, inexpensive Internet devices hold considerable promise.

Another versatile feature of Java is the fact that it can be used on any platform to create programs that are platform-independent. There are Java development tools available for Unix, Windows and Macintosh. Sun has released the (free) "Java Developer's Kit" (JDK) for each of those systems. Sun also makes available on their Web site an on-line tutorial which offers a good introduction to Java. If you're pretty convinced that you want to try your hand at Java development, you're best off buying one of the more full-featured Java development tools now available; they offer quite a bit more help and features than does Sun's JDK. It probably would make sense in that case also to invest in one of the many Java how-to books now on the market. Some are geared to Java development on specific platforms or using certain development tools.

You quite likely would not want to. As with CGI, there are ways to use Java without having to create it from scratch. If that's your interest, you might want to skip ahead to the last section of this page. On the other hand, a rudimentary idea of how Java works might be helpful in using and customizing existing Java applets. Learning to create Java applets is not something recommended for the casual Web user (or for anyone coming up for tenure soon). Unless you're a regular Bill Gates, learning Java is certain to be a time-consuming process and is going especially to be a challenge if you have not had some programming experience. It's going to take the kind of hands-on knowledge best developed in short, intensive learning spurts. You're better off working in a concentrated time frame (say a few weeks over the summer) either through a short course or independently, than you are trying to learn a little bit at a time. If you pick up a Java book or read an article on it in a computer magazine, Java will probably be described as "easy to learn". That's from the perspective of professional programmers used to even more complex languages like C++. Don't be fooled; for non-geeks Java is a challenge. If you thought JavaScript was bad, don't even bother with Java. On the other hand, if you have a basic knowledge of JavaScript, that will be a very good starting point for learning Java. Java is in some ways JavaScript on steroids.

Why bother? As with all the topics covered in this trailguide my ultimate hope is to encourage language teachers to become empowered producers of interactive Web pages. However, I realize that for many of us -- for a variety of good reasons -- that's not a realistic vision. At the least I hope to see language teachers become intelligent consumers of Web technology, a goal I believe is within everyone's grasp. To be an enlightened consumer of technology it's important to know something about the underlying systems, how they're designed to work, what they're capable of and what it takes to learn to use them. Java is on the fast track to becoming the central Web technology, so taking a short peek under the hood -- even if you're not going to re-build the engine -- may be helpful.

Your exposure to Java as a consumer is probably going to come through your Web browser. Java is currently supported on a number of browsers, including Netscape Navigator and Microsoft's Internet Explorer. Such browsers have a Java interpreter built in which runs Java applets downloaded over the Web. However, Java doesn't have to run within a Web browser. It's possible to create stand-alone Java applications which can run on your computer independent of the Web. Although this option offers some interesting possibilities, I won't be discussing it much here; my attention will be directed to Web-based Java applets. When run as applets on a browser, Java programs generally are indistinguishable from regular Web pages in the sense that they are integrated transparently into the browser window displaying the page. Considering the fact that Java can be used to create applets to do just about anything under the sun, this adds an incredible degree of power and flexibility to creating Web pages. Consider the functionality of the programs you have on your computer -- word-processing, spreadsheet, database, graphics editor -- and imagine that functionality being built into Web pages. In terms of language learning this offers not only the equivalent of what can currently be done with stand-alone authoring programs (HyperCard, Toolbook, Authorware, etc.), it goes further, putting that same functionality in a network-ready environment, allowing for exciting possibilities of shared learning and collaboration in a full-featured, electronic environment.

We're not there yet. I'm also not suggesting that any language teacher start developing a Java-based word processor. Many of those functions will be made available through add-ons, some undoubtedly as commercial products. What I can imagine a Java-crazed language teacher creating, however, is a more modest Java applet, say a dual-language >glossary, that integrates with Web documents. Other possibilities might be interactive grammar tutorials linked to exercises, self-learning modules based on the principle of adaptive testing (i.e. with intelligent help) or even virtual classrooms using the network capabilities of Java to create voice/text chat. With the built-in data-streaming capability of Java, there are some exciting prospects for delivering real-time authentic language materials not just in text and graphics as we do now but in audio and video as well. Some of these developments may take a while, but the potential is certainly there.

You will need the following:

1. Text editor for writing the Java code
   
2. Java compiler for creating applets out of your code

You can use any text editor or word processor to write Java code, although the commercial Java tools include editors with Java-specific features such as color-coding or templates. Some editors also have simple "debuggers" which help you find syntax errors before trying to compile your code. You save your code as text, giving it a name with ".java" as the file extension. You then process that file with a compiler. You can use Sun's compiler called Javac or one which comes with a commercial product. Here again, the advantage of the latter are more features. If possible, get a hold of the fastest compiler available for your system. Compiling a file can take a while. You may very well find yourself waiting, waiting, only to be told in an error message that the compile failed -- because you left out a quotation mark. Welcome to the wonderful world of programming! If your compile was a success, a new file was created -- a Java applet! -- with the same name as your original file, but with ".class" as a file suffix. This is a binary not a text file -- you can't look at it with your text editor, you can only run it as an applet. If you want to make changes, you have to go back to your original ".java" file, make and save the changes, then re-compile the file. Not a quick or easy process.

If, miraculously, your code has been successfully compiled into an applet, you'll probably want to actually use it. To do so, you'll need to create an HTML page referencing your applet. Say you've written a file called "pains.java" which does interactive things with different kinds of French bread (or expresses an unhappy experience with Java). You've compiled the file into "pains.class". To have that applet appear within a Web page, you would create a Web page (we'll call it "pains.html") and include in it the following HTML code: "<applet code="pains.class" width = 300 height = 300> </applet>". When a user then calls up that page on the Web, the server delivers not just "pains.html" (the Web page) but also "pains.class" (the applet). The applet appears at the place on the page corresponding to where you placed the "<applet>" tags in your HTML. It takes up a space on the page of 300 pixels wide and 300 pixels high, because that was what was specified in our code. You can align the placement of the applet relative to the other elements of the page using the same kind of aligning tags available for images.

We'll start with a simple example which just displays some text, in this case the line "Seid umschlungen, Millionen!", the more enthusiastic German equivalent (from Friedrich Schiller) of the traditional programmers' "Hello world!". First, here's the HTML of the Web page calling the applet, named "HelloWorld.class":

<html>
<head>
<title>Hello world!</title>
</head><body>
If your browser supports Java, you should see the applet display below.
<applet code="HelloWorld.class" width=200 height = 50>
Your browser does not support Java.
</applet>
</body>
</html>

Note that for users without Java-capable browsers, an alternate message is displayed. Anything between the <applet> tags will be ignored by Java-capable browsers, so you could in addition to text put in an image (screen capture) of what the applet looks like, so folks with other browsers have an idea of what they're missing. The applet when run looks like this:

[Figure 5-1]

Note that what you see here is the applet running in Sun's "Applet Viewer", a small utility which comes with the Java Developer's Kit; it's a quick and easy way to try out your applets.

Here's the code for "HelloWorld.java" (compiled into "HelloWorld.class"):

import java.applet.*;
import java.awt.*;

public class HelloWorld extends Applet {
   
    public void paint(Graphics g) {
    
      g.drawString("Seid umschlungen, ihr Millionen!", 10, 70);
    }
}

We're take a peek at this code, but first let's talk about some core principles of Java. A basic understanding of the structure of the language is necessary to make any sense of the code. Central to Java is the concept of class (it appears in line 3 above). Java is an object-oriented language, which simply means that its fundamental structure is based on the concept of creating and manipulating objects. A class in Java is a kind of ideal representation of a group of objects (akin to Plato's vision of the idea and its embodiment) or a kind of template for objects of a certain kind.

Programming authors like to say that object-oriented programming is so easy and natural because it's modeled on the real world. (Yes, they do offer Florida real estate for sale, as well). Let's therefore take a real-world example to look at the concept and terminology. We can think of fruit as a class -- in a way an abstract notion whose only reality is to be embodied in individual pieces of fruit, i.e. apples, bananas, oranges, etc. or in a mixed group of those individual fruits. In computerese these are members of the fruit class and each kind of fruit -- say a banana -- is an "instance" (or embodiment) of that class. In Java terms when God created apples for Adam and Eve, he "instantiated" apples as members of the fruit class. Pieces of fruit can individually be quite different, but they also show categories of characteristics common to all fruit, like color, taste, shape, texture, etc. In Java terms these are attributes. So let's say (or "declare") members of the class fruit to have the attributes "color" and "shape". We can then define a particular fruit in terms of those attributes. Using Java syntax, we could think of the apple in this way:

apple.color = "red"
apple.shape = "round"

"Red" and "round" are in Java terms "instance variables" -- concrete representations of class attributes for that class member.

Objects in Java don't only have attributes, they also exhibit behaviors ("methods" in Java) -- this is in fact crucial to how objects work. Let's take an example closer to home. Let's consider students as a class with individual students as instances or members of that class. We could define a couple of attributes like major, status or age, which all could then be given (or "initialized") for each student. Let's add another attribute of a different kind, which in contrast to the open-ended attributes like age (which could be 16, 22, 45, 82, etc.) has only two possible values or states, say whether a student is awake or asleep. We'll call that attribute "wakeStatus" (programmers like to play with capitalization) and say it has only two states -- awake (true) or asleep (false) -- although I think you'll agree that in real life many students are somewhere in between. This kind of attribute is called Boolean. We can think of student Schnickelfritz in these terms:

Schnickelfritz.age = "18"
Schnickelfritz.major = "Recreation"
Schnickelfritz.wakeStatus = false

If we don't want Schnickelfritz snoring through our applet, we can create a method to wake him up. Let's call it "wakeUp" -- in Java syntax it would be "wakeUp()". The "()" is for inclusion of optional "arguments" -- in this case, for example, we can use "wakeUp(how)" to define the method and how we want to carry it out. Here are some possibilities:

Schnickelfritz.wakeUp ("yell")
Schnickelfritz.wakeUp ("coffee")
Schnickelfritz.wakeUp ("cattleprod")

This method is associated with this class, i.e. is to be used on students. Will it work on other people, too? That depends -- it has to do with another key concept of Java -- inheritance.

Classes are not there floating in isolation. Typically they are part of a hierarchy. A class can have a "superclass" above it and a "subclass" below it. We could think of students, for example, as a subclass of humans, which is itself a subclass of animals. A great deal of the power and flexibility of Java (and other object-oriented languages) resides in the fact that subclasses "inherit" methods and variables from their superclasses. This means you can define variables and methods at the top of the hierarchy and make them available to all the classes down the line, meaning that a lot of Java code is re-usable -- instead of recreating a certain method, you can just inherit it. When an object (say Schnickelfritz) receives a message (say, "wakeUp"), Java first sees if it's defined in the current class ("students") -- if not it moves up the hierarchy looking till it finds a method definition. You can "override" an existing method of a superclass in a subclass by simply using the same name and changing the behavior. Say "wakeUp()" exists in the human class, but you know it takes a lot more to wake up students, so you redefine your more energetic wakeUp method in the student class, which then takes precedence over the definition in the human class.

What if you want to share variables or methods across classes of different hierarchies. You can do that, too, in Java through "interfaces". Then, if you want to group together a certain group of classes and interfaces, you can create a "package" to do so. This takes us back finally to our "helloWorld" example. The first two lines tell Java that you want to use ("import") the functionality and syntax defined in the classes and interfaces of the "applet" and "awt" ("Abstract Window Toolkit") packages. These become superclasses for our class, allowing us to create appropriate applet behavior and use the graphic and other tools available in the "Abstract Window Toolkit". Our next line defines our new class "HelloWorld" as a member ("extends") of the Applet class. "Public" indicates that the class or method is freely available for access (you can also restrict access). "Paint" is a method defined in AWT which simply draws to the screen a graphics object. In this class we've created the object "g" and will apply the method "drawString()" to it, which writes a string of text. Class and function definitions are surrounded by curly braces.

Why go through all that trouble just to write three words, which is all our applet does? Clearly, you wouldn't think of using Java if that's all you wanted to do. If you're using Java, it's because of the interactivity and multimedia capabilities. Both are modestly demonstrated in the next example, which asks the user to answer a question. Depending on the answer, the applet returns text and audio feedback. Here's the HTML code for intregrating the "JavaQuiz" applet:

<html>
<head>
<title>JavaQuiz</title>
</head>
<body bgcolor=navajowhite>
<h2>Java Quiz</h2>
If your browser supports Java, you should see the applet display below.<br>
Feedback includes playing back an audio file.<p>
<i><b>Answer the question, then hit return.</b></i><br>

<applet code="JavaQuiz.class" width=200 height = 50 align=top>
</applet>

<p>
Note that the applet is integrated transparently into the Web page.
</body>
</html>

Here's theJava source code for "JavaQuiz.java":

import java.applet.*;
import java.awt.*;

public class JavaQuiz extends Applet {

    TextField answer1;
    Label question1;
    AudioClip beep;
    AudioClip ding;
    
    public void init() {
    
       beep = getAudioClip(getCodeBase(), "beep.au");
       ding = getAudioClip(getCodeBase(), "ding.au");
       setBackground(new Color(255,222,173));
       answer1 = new TextField (20);
       question1 = new Label("How much is 2 plus 2?");
       add(question1);
       add(answer1);
       validate();
    }

    public boolean action(Event evt, Object arg) {

       if (answer1.getText().indexOf("4") != -1) {
         answer1.selectAll();
         answer1.setText("Right!");
         ding.play();
       } 
       else {
         answer1.selectAll();
         answer1.setText("Sorry, try again.");
         answer1.selectAll();
         beep.play();
       }
       return true;
    }
}

Here's what the applet looks like after someone has answered incorrectly:

[Figure 5-2]

First in the class definition, a set of variables are "declared", In Java, you have to declare, insubstantiate and initialize variables. In many cases, you can combine the first two steps. The "init()" method is one of several standard methods for applets; it initializes the variable and defines what will be drawn to the screen. In this case it also pre-loads some audio files so they play right away. The "action()" method handles the analysis of the answer given by the user. It uses the same kind of "if...then" conditional structure we saw in the basic CGI example.

Obviously, to take advantage of the full power of Java, you have to learn to program with it. Otherwise you're using what someone else has deemed to be its best use for language learning, or more likely, for general purpose computing. With a tool so new in a medium so young, however, who can say what it's best use might be. However, even if you think you might learn basic Java programming some day, a good first step is to start using existing applets and customizing them for your needs. From there, if you see the need and have the opportunity, you can begin tinkering with creating your own applet from scratch. Keep in mind, however, that it's good programming practice to re-use code -- your own or borrowable code from others. You can quite likely assemble from different programs a skeleton of what is it you want to do. From there all (all?) you have to do is fill in the missing pieces.

How can you customize applets? It's possible only if the author agrees and has made it possible in one of the following ways:

1. Publicly released and heavily commented code (i.e. the ".java" file) that tells you step by step what's going on and how to change it to fit other needs
   
2. External "parameters" (values) for key parts of the applet which can be set from HTML
   
3. Using "LiveConect" (Netscape) or similar means to control an applet from JavaScript, VBScript or other client-side scripting environment

The first option is the trickiest. Programmers are notoriously lax in writing documentation, so it's not easy to find source code with enough help and comments for a non-programmer to be able to re-compile the program successfully with new values. This option is in fact only viable if you have a pretty good grasp of Java programming already.

The second option is probably the easiest and most viable. Programmers can write their Java code in such a way that key methods and variables, instead of being hard-coded in the compiled code can be set by simply entering the value in parameter tags within the applet tags in HTML. To illustrate how this works below is the HTML for a customized version of an applet named ImageMap. The applet creates a "live" clickable picture in which mouse movements or clicks can trigger events such as pop-ups or scrolling text, playing audio files or jumping out to Web sites. I've specified in the parameters to this applet, what graphics file to use (a map of Germany) and the dimensions of the different areas I want to be active on the map:

<html>
<head>
<title>Die deutschen Bundesl&auml;nder</title>
</head>
<body>

<p><applet code=ImageMap.class width=286 height=321 align=left hspace=20>
<param name=img value="germanycroptr.jpg">
<param name=highlight value="brighter30">
<param name=area1 value="NameArea,208,100,23,10,Berlin">
<param name=area2 value="NameArea,105,13,48,44,Schleswig-Holstein">
<param name=area3 value="NameArea,190,78,47,15,Brandenburg">
<param name=area4 value="NameArea,198,113,49,30,Brandenburg">
<param name=area5 value="NameArea,191,97,15,15,Brandenburg">
<param name=area6 value="NameArea,226,100,21,15,Brandenburg">
<param name=area7 value="NameArea,161,35,80,40,Mecklenburg-Vorpommern">
<param name=area8 value="NameArea,159,89,27,65,Sachsen-Anhalt">
<param name=area9 value="NameArea,37,117,65,55,Nordrhein-Westphalen">
<param name=area10 value="NameArea,37,178,46,36,Rheinland-Pfalz">
<param name=area11 value="NameArea,68,219,20,8,Rheinland-Pfalz">
<param name=area12 value="NameArea,38,220,30,20,Saarland">
<param name=area13 value="NameArea,99,154,32,24,Hessen">
<param name=area14 value="NameArea,90,186,23,30,Hessen">
<param name=area15 value="NameArea,93,224,35,17,Baden-Württemberg">
<param name=area16 value="NameArea,71,247,61,52,Baden-Württemberg">
<param name=area17 value="AniArea,134,196,78,110,Bayern">
<param name=area18 value="NameArea,138,160,53,32,Thüringen">
<param name=area19 value="NameArea,197,147,64,38,Sachsen">
<param name=area20 value="NameArea,97,75,17,11,Bremen">
<param name=area21 value="NameArea,128,58,16,13,Hamburg">
<param name=area22 value="NameArea,68,60,52,11,Niedersachsen">
<param name=area23 value="NameArea,55,75,34,34,Niedersachsen">
<param name=area24 value="NameArea,117,74,31,12,Niedersachsen">
<param name=area25 value="NameArea,95,91,51,52,Niedersachsen">
<param name=area26 value="NameArea,110,111,43,30,Niedersachsen">
</applet>

<h2>Die deutschen Bundesl&auml;nder</h2>
Wie hei&szlig;en sie alle? Testen Sie sich!<p>
Warten Sie, bitte, bis die Landkarte erscheint nebenan, dann finden Sie die verschiedenen Bundesl&auml;nder mit der Maus.

</body>
</html>

The "NameArea" coordinates correspond to different federal states ("Bundesländer") of Germany. There are more areas than states because of the existence of a few small city-states within large states, which necessitated dividing those states up into several blocks. When a user passes the mouse cursor over one of the states, its name appears in the status bars as in the following screen shot:

[Figure 5-3]

Note that in this case, the applet is aligned on the left side of the page and the title and instructions (in HTML) are on the right. This process makes it very easy to customize even complex scripts. This applet is a good example of such a script -- it contains seventeen different compiled programs, with over 25 pages of code. Fortunately, to use the applet you need not know how it's put together because the author has been kind enough to make it readily usable by non-programmers. There are, by the way, a number of books on the market which contain Java applets customizable in this same manner.

The third option is to use browser-based scripting to set parameters of the applet. Actually, there are a lot of interconnecting possibilities involving Java, JavaScript and plug-ins. If the applet and plug-in authors have built it into their programs, users can use JavaScript to control the behavior of those programs, for example, to start and stop the playback of a video clip in a plug-in. With Java, any method declared "public" can potentially be controlled by JavaScript. I rewrote the JavaQuiz code, for example, to create a method called "jsAccess()", which is declared "public" and allows input into the field to come from a field or button created with JavaScript and embedded in the HTML. This code is added right after the "init()" definition:

	public void jsAccess (String, jstext) {
		answer1.setText(jstext);
	}

The "jstext" variable is the input from JavaScript. This kind of interconnectivity offers a lot of potential for accessing and controlling applets from HTML elements like buttons or form fields. This combines the ease of authoring of HTML/JavaScript with the power of Java.

It's too early to tell. There has been considerable hype in the news media about the impending arrival of "NC's" -- network computers without hard drives running off the Internet. If this is to become a reality those programs will almost certainly be written principally in Java, at least for the foreseeable future. But we're a ways away from this vision being workable for a large number of folks, simply because of network and bandwidth issues. Total network reliance only makes sense in a world of bullet-proof networks and redundant systems. We're not just talking about text anymore, so the networks are going to have to be broad and fast enough to support audio and video streaming. Even if NC's were flexible, would they be a good idea? Who wants to have to access their word processor over a network? Anyone who's used Microsoft Word on a Novell network can tell you the pitfalls of that arrangement. The big advantage of network-based applications are price, availability and timeliness. If network computers can be made very inexpensively, they're likely to get wide distribution and use, bringing down software prices due to a mass market. Instead of buying high-priced, fully-featured, one-size fits all software, you would rent by connect-time more customized applications. Those of us in language learning have been keenly aware of how ill-fitting main-stream word processor sare to our multi-lingual needs. Programs such as Nota Bene (Dos) and Nisus (Mac) are much more fully-featured for our purposes (Nota Bene had Microsoft Word's touted automatic replacement macros and correct-as-you-type spell checking in 1988). Those programs, as good as they are, have never gotten wide use, even among language professionals because of availability, pricing and system compatibility issues. If Java applets are widely distributed and cross-platform, they stand a better chance of succeeding.

One of the possible impediments to this vision is the likelihood of system-specific Java implementations which run only on certain computers. I hope that we can avoid this path and I would urge would-be developers to think and act globally. The Internet is still a culture dominated by sharing and tools like Java make that easy to do; it would be a shame to give up on this vision. Another less idealistic reason for portable code is the possibility of running Java on devices other than PC's. For the educational market, there is a lot of educational potential in such products.

Information/Documentation/Tutorials

Java 101 basics from ZDNet
Introduction to Java tutorial from IBM (Windows only)
Java Tutorial from Sun (all platforms)
Jamba commercial Java templates
JDK Java Developer's Kit from Sun
Emblaze Creator tool for delivering streaming media and presentations through Java
Java World on-line periodical

Examples/Collections/Demonstrations

Java-based dictionaries French, German and Spanish (University of Lethbridge) Multilingual Word Match Game From Sun Applets downloadable Java applets from Sun
Java Applets Pack applet collection from techweb
Java Test generator from Purdue
Educational Applets from Gamelan
Educational Object Economy from Apple
Java Applet Rating Service tracks new applets
Earth Web Chat easily build Java-powered chat