A really brilliant piece of software that allows you to do just that is called ESPER. You can find the website of the project right here. Esper provides programmers with a language called EPL, mildly similar to SQL, that facilitate the configuration of the rules and patterns that will be applied on the data stream.

The documentation that comes with ESPER is quite complete, but it lacks practical examples, which makes it look like Esper is complicated to use. So here it is, a five minutes guide to Esper. Esper is available in Java, and C#, although the example that follows is written in Java. I assume that you have already downloaded Esper, which can be done by clicking on this link. After unzipping the file you have just downloaded, you should have a folder called esper-3.1.0 somewhere on your disk.

Before getting started, you need to add a couple of libraries to your project. Of course, esper-3.1.0.jar is one of them, but you also need four third-party libraries that are all located in the esper-3.1.0/esper/lib folder.

The five minutes start now. The data we would like to analyze need to be structured in the form of objects before it can be thrown down the pipe to our CEP engine. Let us use a simple example and write a class (some may call it a bean) that represents a stock price at a given time (a stock tick).

import java.util.Date;
    public static class Tick {
        String symbol;
        Double price;
        Date timeStamp;

        public Tick(String s, double p, long t) {
            symbol = s;
            price = p;
            timeStamp = new Date(t);
        }
        public double getPrice() {return price;}
        public String getSymbol() {return symbol;}
        public Date getTimeStamp() {return timeStamp;}

        @Override
        public String toString() {
            return "Price: " + price.toString() + " time: " + timeStamp.toString();
        }
    }

It has three properties: a symbol name (say “AAPL” for Apple’s stock), a price and a time stamp. Before we start generating billions of ticks, we need to inform the engine about the the kind of objects it will have to handle. This is done via the “Configuration” object that is used when instantiating the CEP engine.

import com.espertech.esper.client.*;

public class main {

   public static void main(String [] args){

    //The Configuration is meant only as an initialization-time object.
    Configuration cepConfig = new Configuration();
    // We register Ticks as objects the engine will have to handle
    cepConfig.addEventType("StockTick",Tick.class.getName());

   // We setup the engine
EPServiceProvider cep = EPServiceProviderManager.getProvider("myCEPEngine",cepConfig);
   }
}

import java.util.Random;
import com.espertech.esper.client.*;

public class exampleMain {
   private static Random generator=new Random();

   public static void GenerateRandomTick(EPRuntime cepRT){
    double price = (double) generator.nextInt(10);
    long timeStamp = System.currentTimeMillis();
    String symbol = "AAPL";
    Tick tick= new Tick(symbol,price,timeStamp);
    System.out.println("Sending tick:" + tick);
    cepRT.sendEvent(tick);
}

    public static void main(String[] args) {
     //The Configuration is meant only as an initialization-time object.
      Configuration cepConfig = new Configuration();
     cepConfig.addEventType("StockTick",Tick.class.getName());

      EPServiceProvider cep=EPServiceProviderManager.getProvider("myCEPEngine",cepConfig);

      EPRuntime cepRT = cep.getEPRuntime();
    }
}

Now we have a working CEP engine and a fake data feed, it is time to create our first rule, or in the Esper parlance, our first EPL statement. To do so we need to ask the administrator of the engine to record our statement. The CEP engine will then filter the data it receives, and trigger events whenever that data meets the selection rule, or fulfills the pattern defined in the statement.

 public static void main(String[] args) {
//The Configuration is meant only as an initialization-time object.
Configuration cepConfig = new Configuration();
cepConfig.addEventType("StockTick",Tick.class.getName());
EPServiceProvider cep = EPServiceProviderManager.getProvider("myCEPEngine",cepConfig);
EPRuntime cepRT = cep.getEPRuntime();

// We register an EPL statement
EPAdministrator cepAdm = cep.getEPAdministrator();
EPStatement cepStatement = cepAdm.createEPL("select * from " +
                                "StockTick(symbol='AAPL').win:length(2) " +
                                "having avg(price) > 6.0");
    }

The next step now consists in creating a listener and connect it to the events generated by our selection rule. This can be done as follows:

cepStatement.addListener(new CEPListener());

public static class CEPListener implements UpdateListener {
 public void update(EventBean[] newData, EventBean[] oldData) {
         System.out.println("Event received: "
                            + newData[0].getUnderlying());
    }
}

for(int i = 0; i< 5; i++)
    GenerateRandomTick(cepRT);

import com.espertech.esper.client.*;
import java.util.Random;
import java.util.Date;

public class exampleMain {

    public static class Tick {
        String symbol;
        Double price;
        Date timeStamp;

        public Tick(String s, double p, long t) {
            symbol = s;
            price = p;
            timeStamp = new Date(t);
        }
        public double getPrice() {return price;}
        public String getSymbol() {return symbol;}
        public Date getTimeStamp() {return timeStamp;}

        @Override
        public String toString() {
            return "Price: " + price.toString() + " time: " + timeStamp.toString();
        }
    }

    private static Random generator = new Random();

    public static void GenerateRandomTick(EPRuntime cepRT) {

        double price = (double) generator.nextInt(10);
        long timeStamp = System.currentTimeMillis();
        String symbol = "AAPL";
        Tick tick = new Tick(symbol, price, timeStamp);
        System.out.println("Sending tick:" + tick);
        cepRT.sendEvent(tick);

    }

    public static class CEPListener implements UpdateListener {

        public void update(EventBean[] newData, EventBean[] oldData) {
            System.out.println("Event received: " + newData[0].getUnderlying());
        }
    }

    public static void main(String[] args) {

//The Configuration is meant only as an initialization-time object.
        Configuration cepConfig = new Configuration();
        cepConfig.addEventType("StockTick", Tick.class.getName());
        EPServiceProvider cep = EPServiceProviderManager.getProvider("myCEPEngine", cepConfig);
        EPRuntime cepRT = cep.getEPRuntime();

        EPAdministrator cepAdm = cep.getEPAdministrator();
        EPStatement cepStatement = cepAdm.createEPL("select * from " +
                "StockTick(symbol='AAPL').win:length(2) " +
                "having avg(price) > 6.0");

        cepStatement.addListener(new CEPListener());

       // We generate a few ticks...
        for (int i = 0; i < 5; i++) {
            GenerateRandomTick(cepRT);
        }
    }
}

log4j:WARN No appenders could be found for logger (com.espertech.esper.epl.metric.MetricReportingPath).
log4j:WARN Please initialize the log4j system properly.
Sending tick:Price: 6.0 time: Tue Jul 21 01:11:15 CEST 2009
Sending tick:Price: 0.0 time: Tue Jul 21 01:11:15 CEST 2009
Sending tick:Price: 7.0 time: Tue Jul 21 01:11:15 CEST 2009
Sending tick:Price: 4.0 time: Tue Jul 21 01:11:15 CEST 2009
Sending tick:Price: 9.0 time: Tue Jul 21 01:11:15 CEST 2009
Event received: Price: 9.0 time: Tue Jul 21 01:11:15 CEST 2009

As you can see, only the last two ticks have an average above the value of 6.0, and therefore only one event was triggered by the engine. Fantastic!

Oh, you maybe worry about the two first lines. Yeah, there is still a bit of an issue to sort out. In fact, Esper uses a logging package called log4j that causes these warnings. It can be configured using a file called log4j.xml which you will find in the /etc folder of one of the example project in esper-3.1.0/examples. I don’t think that having a XML configuration file for everything is a very good idea and therefore I have used to following trick to configure the logger. Add the following imports at the beginning of your file:

import org.apache.log4j.ConsoleAppender;
import org.apache.log4j.SimpleLayout;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;

 public static void main(String [] args){

      SimpleLayout layout = new SimpleLayout();
      ConsoleAppender appender = new ConsoleAppender(new SimpleLayout());
      Logger.getRootLogger().addAppender(appender);
      Logger.getRootLogger().setLevel((Level) Level.WARN);
(...)

The five minutes are now over.

In my next posts, I will explore EPL statements a little bit more in depth, and provide some code to connect two engines together in order to facilitate what is called “event refinement”.

Esper is a Complex Event Processor (CEP). In other words, it is an engine that detects patterns in a stream of high-frequency data, and notify them by sending an event (in the form of a Java object) to a listener. In short:

Basically instead of working as a database where you put stuff in to later poll it using SQL queries, Esper works as real time engine that triggers actions when event conditions occur among event streams. A tailored Event Processing Language (EPL) allows registering queries in the engine, using Java objects (POJO, JavaBean) to represent events. A listener class – which is basically also a POJO – will then be called by the engine when the EPL condition is matched as events come in. The EPL allows expressing complex matching conditions that include temporal windows, and join different event streams, as well as filter and sort them.

It’s all Java, terribly smart, simple and yet diabolically complete. Everything works with POJOS (no bullshit java objects) and there are testing units. Oh, and it’s really, really fast. It ships with a query language that is already strangely familiar to those who used to work with SQL.

I will post bits of code on how to use Esper pretty soon, stay tuned.

For those of you who need an introduction on Complex Event processing, they can read this series of articles by Tim Bass:
What is complex event processing (part 1)

The other parts follow right after it.

Unlike daily closing and opening prices, you won’t be able to simply download tick data in the .csv format to feed your favorite strategy back-tester. You can write an HTML-scraper and let it run for a month or two 24/7 to get a few MB of data.

However, yahoo and google protect themselves against scrapers and hence it is very likely that you won’t be able to get an uninterrupted stream of quotes this way. For instance, yahoo will give you its very infamous 999 error, which is their http-server way of giving a finger to suspiciously busy users.

You can get around this by a cunning use of proxy servers, and of course, decreasing the frequency of your requests to the server. I will maybe publish the code I used to do it, although I still need to assess the legality of the whole thing before taking the plunge.

In the meantime, I found this:
Free samples of tick data
You can download samples of high-frequency data from different exchanges. Since I only need high-freq data for testing purposes, this is good enough for me, and so maybe for you too.

A quick one for those who read the books of Nassim Taleb. Three black swans were born last week in Basel.

This script download a .csv file containing the historical data from today to the day of your choice for each stock listed on the S&P 1000.

First, you need to download the .csv file containing the symbol of every stock listed on the S&P 1000. This file can be found here. In my case, the file is named 17-FEB-1009_1000.csv.

Then, copy the following to a file called yahooDown.sh :

#!/bin/bash
# prices from S&P500 can be downloaded from
#http://www2.standardandpoors.com/portal/site/sp/en/us/page.topic/indices_500/2,3,2,2,0,0,0,0,0,2,3,0,0,0,0,0.html

# We download from today to the date in the command line

#./yahooDown.sh standardPoorList.csv DestDir 1-1-1995
# e.g. ./yahooDown.sh 17-FEB-2009_1000.csv SP1000 1-1-1995

todayDate=$(date "+%d %m %Y")

# Start date
sDay=$(echo $todayDate | awk '{print $1}')
sMonth=$(echo $todayDate | awk '{print $2}')
sYear=$(echo $todayDate | awk '{print $3}') 

# end date

eDay=$(echo $3 | sed "s:-: :g" | awk '{print $1}')
eMonth=$(echo $3 |sed "s:-: :g" | awk '{print $2}')
eYear=$(echo $3 |sed "s:-: :g" | awk '{print $3}') 

# command to fetch data the CSV files from yahoo

DESTDIR=$2
WGET="curl"
OPT1="-o"

COM1="http://ichart.finance.yahoo.com/table.csv?s="
COMd="&d="$(expr $sMonth - 1)
COMe="&e="
COMf="&f="
COMg="&g=d"
COMa="&a="$(expr $eMonth - 1)
COMb="&b="
COMc="&c="
COMlast="&ignore=.csv"

# the command we pass to wget
for i in $(sed -e "s:,: :" -e "/Symbol*/ d" -e "/^$/ d" $1 | awk '{print $1}'); do

echo "Downloading the data for symbol " $i
WEBURL="$COM1$i$COMa$COMb$eMonth$COMc$eYear$COMd$COMe$sMonth$COMf$sYear$COMg$COMlast"
COMMAND="$WGET $OPT1 "$DESTDIR/$i.csv" "$WEBURL""
$COMMAND

done

Now you need to turn it into an executable file. Open a terminal in the directory where the file yahooDown.sh is located and type:

$ chmod +x yahooDown.sh

Now, create a directory where you want the .csv files of each stock to be placed:

$ mkdir SP1000

Now, just type:

$ ./yahooDown.sh 17-FEB-2009_1000.csv SP1000 1-1-1998

Just wait a bit... You should see something like this:

$ ./yahooDown.sh 17-FEB-2009_1000.csv SP1000 1-1-1990
Downloading the data for symbol  COMS
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  217k    0  217k    0     0  60340      0 --:--:--  0:00:03 --:--:-- 65004
Downloading the data for symbol  NDN
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  147k    0  147k    0     0  26304      0 --:--:--  0:00:05 --:--:-- 35161
Downloading the data for symbol  AHC
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 10817    0 10817    0     0  24368      0 --:--:-- --:--:-- --:--:-- 43963

and voilà! The historical data of every stock listed on the S&P1000 is now ready to be used in the directory SP1000. Here is a (partial) listing of the same directory on my machine:

$ ls
AAI.csv		CCMP.csv	FIC.csv		KND.csv		ORLY.csv
AAP.csv		CCRN.csv	FIF.csv		KNDL.csv	OSG.csv
ABAX.csv	CDI.csv		FINL.csv	KNOT.csv	OSK.csv
ABCW.csv	CDNS.csv	FL.csv		KNSY.csv	OSTE.csv
ABFS.csv	CDR.csv		FLO.csv		KNX.csv		OXM.csv
ABM.csv		CEC.csv		FMBI.csv	KOPN.csv	OXPS.csv
ACAP.csv	CECO.csv	FMC.csv		KRC.csv		PACW.csv
ACAT.csv	CELL.csv	FMER.csv	KRG.csv		PALM.csv
ACF.csv		CEM.csv		FNF.csv		KSU.csv		PAS.csv
ACI.csv		CENTA.csv	FNFG.csv	KSWS.csv	PBKS.csv
ACIW.csv	CENX.csv	FOE.csv		KWK.csv		PBY.csv

Okay, that's all folks.

In this first post, we will simply write a couple a classes that actually emit and receive events. In order to introduce the concept of event-driven programming, we will use an analogy with the notes (the events) that are produced by instruments, and caught by listeners.

We first define what we call a sound event. A sound is formed by a note, which we encode on an integer, and a time stamp that corresponds to the moment the note was played.

public class SoundEvent extends EventObject {

    private Integer note;
    private long timestamp;

    public SoundEvent(Object source, Integer s, long time) {
        super(source);
        note = s;
        timestamp = time;
    }

    public Integer getNote() {
        return note;
    }

    public long getTimeStamp() {
        return timestamp;
    }
}

This class extends EventObject, which contains only one variable storing the object that created the event (the source), and a function to retrieve it [the method getSource()].

Then, we create the SoundMaker class. This class will generate sounds at random, and fire sound events.

public class SoundMaker {

    private Integer sound;
    private List listeners; // List of listeners
    private Random rgen; // Random generator of sounds
    private long timeReference; // time is counted from this reference

    public SoundMaker() {
        listeners = new ArrayList();
        rgen = new Random();
        sound = new Integer(0);
        timeReference=0;
    }

    public void setTimeReference(long i){
    timeReference=i;
    }

    //---end of class
}

We will now add a couple of methods to this class. First, two functions that will allow us to add listeners to the list of the soundMaker class.

public synchronized void addListener(SoundListener sl) {
        listeners.add(sl);
    }

    public synchronized void removeListener(SoundListener sl) {
        listeners.remove(sl);
    }

Of course, we also need a function that plays notes, or even entire concerts!

public synchronized void playNote() {
        sound = rgen.nextInt(1000);
        long now = System.currentTimeMillis()-timeReference;
        System.out.println("[SoundMaker] Playing note " + sound + " @ " + now);
        fireSoundEvent(now);
    }

    public synchronized void playConcert(int nbNotes) {

        for (int j = 0; j < nbNotes; j++) {
            playNote();
        }
    }

And finally, the most important function of this class, the fireSoundEvent function that will inform every listener that a sound has been played.

public synchronized void fireSoundEvent(long time) {
        SoundEvent soundEvent = new SoundEvent(this, sound, time);
        Iterator it = listeners.iterator();

        while (it.hasNext()) {
            SoundListener sl = it.next();
            sl.soundReceived(soundEvent);
        }
    }

In order to write classes able to listen to the sound of SoundMaker, we define a simple interface that these classes will have to implement:

public interface SoundListener {
    public void soundReceived(SoundEvent event);

}

As an illustration, we write a MusicFan class, that will listen to the event produced by the SoundMaker class:

public class MusicFan implements SoundListener {

    private long timeReference;

    public void setTimeReference(long i){
    timeReference=i;
    }

    public void soundReceived(SoundEvent sound) {

        long now = System.currentTimeMillis()-timeReference;
        long soundTime = sound.getTimeStamp();
        long timelag = now - soundTime;
        Integer note = sound.getNote();

        System.out.println("[Music fan] " +
        " Hearing note "+ note +
        " @ "+ now +
        " ( with lag = "+ timelag + " )");

      //  Wait.millisec(20);

    }
}

We will use the Wait.millisec(long i) function later, but here is its definition:

public class Wait {

    public static void millisec(long nbMsec){
    long t0,t1;
        t0=System.currentTimeMillis();
        do{
            t1=System.currentTimeMillis();
        }
        while (t1-t0<nbMsec);
    }

}

Okay, now we are ready to write a simple program that connects a listener to a sound maker, and makes it print the note that it has heard.

public class Main {

    public static void main(String[] args) {
        // we create the two classes
        SoundMaker concert= new SoundMaker();
        MusicFan musicfan= new MusicFan();

        // We connect the music fan to the sound maker
        concert.addListener(musicfan);

        // We define the time reference
        long timeReference= System.currentTimeMillis();

        concert.setTimeReference(timeReference);
        musicfan.setTimeReference(timeReference);

        System.out.println("-----------");
        // Go!
        concert.playConcert(10);

    }
}

This produces the following output:

[SoundMaker] Playing note 127 @ 0
[Music fan]  Hearing note 127 @ 1 ( with lag = 1 )
[SoundMaker] Playing note 564 @ 1
[Music fan]  Hearing note 564 @ 1 ( with lag = 0 )
[SoundMaker] Playing note 748 @ 1
[Music fan]  Hearing note 748 @ 1 ( with lag = 0 )
[SoundMaker] Playing note 38 @ 1
[Music fan]  Hearing note 38 @ 1 ( with lag = 0 )
[SoundMaker] Playing note 293 @ 1
[Music fan]  Hearing note 293 @ 1 ( with lag = 0 )
[SoundMaker] Playing note 558 @ 1
[Music fan]  Hearing note 558 @ 1 ( with lag = 0 )
[SoundMaker] Playing note 100 @ 2
[Music fan]  Hearing note 100 @ 2 ( with lag = 0 )
[SoundMaker] Playing note 5 @ 2
[Music fan]  Hearing note 5 @ 2 ( with lag = 0 )
[SoundMaker] Playing note 985 @ 2
[Music fan]  Hearing note 985 @ 2 ( with lag = 0 )
[SoundMaker] Playing note 140 @ 2
[Music fan]  Hearing note 140 @ 2 ( with lag = 0 )

Okay, that seems to work alright. However, there is an interesting question that can be asked: what about the garbage collector. Is it going to disturb the emission of notes, or simply quietly work in parallel to the main thread? This is a very important point when dealing with real-time data, since we absolutely do not want to loose data points received while the garbage collection is running. This has been for a long time one of the main argument against the use of Java for real-time applications, so it is quite interesting to test it.

I have plotted the time lag between the emission and reception of the event over a period of roughly two seconds. As one can see, the reception of the eventObject is instantaneous most of the time. Sometimes tough, it seems that the the reception is slightly delayed, by at most one millisecond. The usual suspect in this case would be the garbage collector. However the introduction of "memory leaks" in the program, e.g. by allocating large arrays on the heap everytime that a sound event is fired, does not seem to increase the size of the lags. Therefore, I believe that it would be erroneous to jump to a conclusion too quickly and declare that garbage collection is responsible to delaying the processing of events. A good test would be to write the same piece of code C++ and check whether the time lags disappear. I was actually quite surprised by this observation, as I thought that the garbage collection would be more visible.

One last comment before I finish this post. Let's see how does the program reacts when we uncomment the waiting function. This function simulates the effect of a listener that would take some time to process the data that was sent to him. So, let us redefine the eventReceived function:

public void soundReceived(SoundEvent sound) {

        long now = System.currentTimeMillis()-timeReference;
        long soundTime = sound.getTimeStamp();
        long timelag = now - soundTime;
        Integer note = sound.getNote();

        System.out.println("[Music fan] " +
        " Hearing note "+ note +
        " @ "+ now +
        " ( with lag = "+ timelag + " )");

       Wait.millisec(20);

    }

The output of the program is now:

[SoundMaker] Playing note 32 @ 0
[Music fan]  Hearing note 32 @ 1 ( with lag = 1 )
[SoundMaker] Playing note 131 @ 22
[Music fan]  Hearing note 131 @ 22 ( with lag = 0 )
[SoundMaker] Playing note 910 @ 42
[Music fan]  Hearing note 910 @ 42 ( with lag = 0 )
[SoundMaker] Playing note 969 @ 62
[Music fan]  Hearing note 969 @ 62 ( with lag = 0 )
[SoundMaker] Playing note 272 @ 82
[Music fan]  Hearing note 272 @ 82 ( with lag = 0 )
[SoundMaker] Playing note 414 @ 102
[Music fan]  Hearing note 414 @ 102 ( with lag = 0 )
[SoundMaker] Playing note 793 @ 122
[Music fan]  Hearing note 793 @ 122 ( with lag = 0 )
[SoundMaker] Playing note 953 @ 142
[Music fan]  Hearing note 953 @ 142 ( with lag = 0 )
[SoundMaker] Playing note 112 @ 162
[Music fan]  Hearing note 112 @ 162 ( with lag = 0 )
[SoundMaker] Playing note 261 @ 182
[Music fan]  Hearing note 261 @ 182 ( with lag = 0 )

You will note that the SoundMaker waits until every one of its listeners have finished to process the sound that was sent to them. This is not quite as in reality, where the arrival time of events is independent of the processing time of the data.

That's all for today folks.

Concept behind functions taking a variable number of parameters is quite simple really: the preprocessor places each parameter in an array and passes it to the function as a unique argument. As in C++, the syntax used in Java is the type of the parameters directly followed by an ellipsis.

In order to illustrate the use of this feature, I have written a small class whose purpose is simply to write in a file the parameters that are passed to a function separated by a coma (the .csv format).

Since this class clearly works as a sort of log, we will use a singleton pattern to make sure that only one instance of the class can exist at once. This also insures that the log file is only created once. So, we start by writing a simple singleton class:

public class LogCSV{
static private  LogCSV thisLog=null;
private FileWriter file;

// The Singleton initializer

static public LogCSV initialize(){
if(thisLog==null){
thisLog = new LogCSV();
}
return thisLog;
}

// The class constructor

private LogCSV(){
try {
file = new FileWriter("strategyLog.csv");

// some compulsory error catching...
} catch (IOException ex) {
Logger.getLogger(LogCSV.class.getName()).log(Level.SEVERE, null, ex);
}
}
}

Now, here it comes. The following “write” function will take a variable number of arguments, and write each of them separated by a coma in a file.

 public void write(String... message) {
        int counter = 0;

        try {

            for (String msg : message) {

                file.write(msg);
                if (counter != message.length - 1) {
                    file.write(",");
                }

                counter++;
            }

            file.write("\n");

        // Error catching jiberish
        } catch (IOException ex) {
            Logger.getLogger(LogCSV.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

Note the ellipsis after the type of the first and unique parameter of the function. This indicates to the compiler that the number of parameters may vary. Also, note the form of the “for” statement. As I mentionned earlier, the parameters are essentially copied to an array and passed to the function in this form. Therefore, the actual number of parameters can be obtained by retrieving the size of the array using

message.length

This class can be used as follows:

LogCSV log= LogCSV.initialize();
log.write("A","B","C");

This will write the sequence

A,B,C

in the file "strategyLog.csv".

Alright, that's all folks. Oh, before I put my pen down, I sometimes use a little trick when dealing with singleton classes. I just add this function to the class:

static public LogCSV execute() {
return thisLog;
}

So that after the class has been initialized, I can call it from anywhere in my code using:

LogCSV.execute().write("C","B","C")

Okay, my turn to ask the questions now. Can someone tell me whether it is the compiler or the precompiler that processes the ellipsis. Also, is this syntax of the "for" reserved for functions taking a variable number of parameters, or is it used in other circumstances? I have not seen it elsewhere, so I was just wondering.

Let’s get started then.

class coffeeOneSugar {
static public void main(String[] args){
System.out.println("OnLine!");
}
}