ECOCRYPT

King's View of the Battle

2023-06-17T09:31:00.002-05:00

Open GL model of a chess board.

Bitcoin Trading Algorithm Back Testing Project Historical Data Setup

2020-02-09T21:45:00.000-06:00

I have the desire to create a bitcoin algorithmic trader which will work autonomously without supervision. However, it might be a wise idea to initially test this trader out with a backtesting solution first. Once the back testing proves profitable, I can then think about the actual autonomous side of the trading.

That said, I have access to historical trade data from the Coinbase Pro (formerly GDAX) exchange. The data is not the full order book, but a very simplified view which shows the "Ticker" after each "Match". For my backtesting application this should be adequate, and the trading strategy that I intend to employ will only need the ticker information.

Goal of this phase:

Organize the Ticker data I have into a usable Backtesting structure
Create an API that will allow a Backtesting Application to request the next Tick, or skip an entire day of Ticks if the daily high or daily low is tighter (narrower) than the autonomous trader is quoting.
Develop unit tests and check the overall performance of the system

Thinking backwards from the end solution, will allow for a usable design. In the end API, it would be nice to be able have:

An autonomous Trader; A "Tick Provider"; and a "Quote Handler" -> Produce a List of Trades and a Profit and Loss Report

The current task at hand is to develop the "Tick Provider". So taking a quick look at the data, it comes in "Daily Files" as:

Ticker_20190928.gz Ticker_20191204.gz

Ticker_20190929.gz Ticker_20191205.gz

Ticker_20190930.gz Ticker_20191206.gz

Ticker_20191001.gz Ticker_20191207.gz

Ticker_20191002.gz Ticker_20191208.gz

Ticker_20191003.gz Ticker_20191209.gz

Ticker_20191004.gz Ticker_20191210.gz

Ticker_20191005.gz Ticker_20191211.gz

Each file is a compressed set of "JSON" data with many different "Products" in it. An example of a few rows of json are shown below:

{
  "gdaxv": "tpid",
  "type": "ticker",
  "trade_id": 2577287,
  "sequence": 488009902,
  "time": "2019-09-28T05:21:19.586000Z",
  "product_id": "ETC-USD",
  "price": "4.73",
  "side": "sell",
  "last_size": "2551.79500000",
  "best_bid": "4.728",
  "best_ask": "4.731"}
{
  "gdaxv": "tpid",
  "type": "ticker",
  "trade_id": 75022004,
  "sequence": 10913413268,
  "time": "2019-09-28T05:22:14.457000Z",
  "product_id": "BTC-USD",
  "price": "8165.28",
  "side": "buy",
  "last_size": "0.00585052",
  "best_bid": "8165.27",
  "best_ask": "8165.28"}

The goal for this segment of the overall project will be the following:

Identify if a daily summary and extraction exists for the desired product/day.

If Not Create the daily summary
Use the existing daily summary

Provided a request based feed of the price ticks for the requested product.
Allow for an entire day of data to be skipped if the Max or Min price are tighter that required by the client using the data (in this case the autonomous trader may choose to list trade bounds)

The basic API will work a follows:

Initialize the Exchange via the constructor and then calling the init() method. I separated out the init method because it could raise an exception and does disk io work like looking for files and making sure that your cache is pre-built. The idea here is that you will want to run a series of tests against the same product data and same time range. The first setup might take a bit, but then after that the data will get processed faster.

A sample header will look like this:

{
  "day": "20190929",
  "product": "BCH-USD",
  "open": 227.63,
  "close": 218.17,
  "high": 228.11,
  "low": 212.0}

Followed by all the trades that match the given product.
After init() is called, then Exchange.next() can be called repeatedly until a NULL is returned indicating the last trade in the set for analysis.
This can be used by an autonomous trader to calculate a position or re-quote. Currently it would be too much work to make this back tester behave exactly as an really exchange API But this will be good enough for simple tests.

The EXCHANGE CODE:

/*

* Copyright (c) 2020. Ecocrypt.com

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*     http://www.apache.org/licenses/LICENSE-2.0

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/
package com.ecocrypt.backtesting.exchange;

import com.google.gson.Gson;

import java.io.*;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.logging.Logger;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;

public class ExchangeFeed {

    private static final Logger LOGGER = Logger.getLogger(ExchangeFeed.class.getName());


    private final Date startDate;
    private final Date endDate;
    private final List<String> fileDateStrings = new ArrayList<>();
    private final Calendar calendar;
    private final String cacheDir;
    private final String dataDir;
    private final String product;
    private final AtomicBoolean isReady = new AtomicBoolean(false);

    private Gson gson = Util.gson();
    private Queue<String> cacheQueue = new LinkedList<>();
    private BufferedReader currentFileReader = null;


    public ExchangeFeed(String pStart, String pEnd,String pDataDir, String pCacheDir, String pProduct){

        cacheDir=pCacheDir;
        dataDir=pDataDir;
        product=pProduct;
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date tStartDate = new Date();
        Date tEndDate = new Date();

        try {
            tStartDate = sdf.parse(pStart);
            tEndDate = sdf.parse(pEnd);

        } catch (ParseException e) {

            e.printStackTrace();
        }
        startDate = tStartDate;
        endDate=tEndDate;
        calendar = new GregorianCalendar();
        calendar.setTime(startDate);


        while (calendar.getTimeInMillis()<=endDate.getTime()){
            fileDateStrings.add(Util.yyyyMMdd(calendar));
            calendar.add(Calendar.DATE, 1);
        }
    }

    public void init() throws IOException {
        checkCache();
        cacheQueue.addAll(fileDateStrings);
        progressReaderToNextFile();
        isReady.set(true);
    }

    public Ticker next(){
        String result = null;
        if(isReady.get()){
            if(currentFileReader!=null){
                try {
                    result = currentFileReader.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if(result==null){
                    try {
                        progressReaderToNextFile();
                        if(currentFileReader!=null) {
                            result = currentFileReader.readLine();
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }else{
            throw new IllegalStateException(" Call initialize before for first use...");
        }
        Ticker resultTicker = null;
        if(result!=null){
            resultTicker = gson.fromJson(result, Ticker.class);
        }
        return resultTicker;
    }



    void printFileDateStrings(){
        fileDateStrings.stream().forEach(System.out::println);
    }

    void checkCache(){
        fileDateStrings.stream().forEach(s -> {
            File cacheFile = new File(cacheDir+ File.separator+product+"_"+s+".gz");
            if(cacheFile.exists()){
                System.out.println("Using Cache Data "+ cacheFile.getAbsoluteFile());
            }else{
                File rawFile = new File(dataDir+File.separator+"Ticker_"+s+".gz");
                if(rawFile.exists()) {
                    System.out.println("Processing " + rawFile
                            .getAbsoluteFile() +"\n\t INTO Cache -> " + cacheFile.getAbsoluteFile());
                    if(processRawFile(rawFile,cacheFile,s)!=0){
                        // Error processing Data.
                    }
                }else{
                    System.out.println("RAW DATA FILE MISSING " + rawFile.getAbsoluteFile());

                }
            }
        });
    }

    private void progressReaderToNextFile() throws IOException {
        String nextDate = cacheQueue.poll();
        if(nextDate!=null){
            currentFileReader = new BufferedReader(new InputStreamReader(new GZIPInputStream(new FileInputStream(new File(cacheDir+File.separator+product+"_"+nextDate+".gz")))));
            String header = currentFileReader.readLine();
            System.out.println("Header: " + header);
        }else{
            currentFileReader =null;
        }
    }



    private int processRawFile(File rawFile, File cacheFile, String s) {
        int result = -1;

        String tempFile = cacheDir+File.separator+"temp_"+product+"_"+s+".gz";
        OCHLDailyStat stats = new OCHLDailyStat();
        stats.setProduct(product);
        stats.setDay(s);
        Gson g = Util.gson();
        AtomicBoolean firstTrade = new AtomicBoolean(false);
        try (GZIPInputStream inputStream = new GZIPInputStream(new FileInputStream(rawFile));
            BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
            GZIPOutputStream os = new GZIPOutputStream(new FileOutputStream(tempFile));
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os))) {


            String line = reader.readLine();

            while(line!=null){
                Ticker t = g.fromJson(line, Ticker.class);

                if(product.equalsIgnoreCase(t.getProduct())){
                    if(firstTrade.compareAndSet(false, true)){
                        stats.setOpen(t.getPrice());
                        stats.setHigh(t.getPrice());
                        stats.setLow(t.getPrice());
                    }
                    bw.write(line);
                    bw.newLine();
                    if(t.getPrice()<stats.getLow()){
                        stats.setLow(t.getPrice());
                    }
                    if(t.getPrice()>stats.getHigh()){
                        stats.setHigh(t.getPrice());
                    }
                    stats.setClose(t.getPrice());
                }
                line = reader.readLine();
            }

            bw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try(BufferedOutputStream bos = new BufferedOutputStream(new GZIPOutputStream(new FileOutputStream(cacheFile)));
        BufferedInputStream bis = new BufferedInputStream(new GZIPInputStream(new FileInputStream(tempFile)))){

            String statsAsString = g.toJson(stats);
            statsAsString +="\n";
            bos.write(statsAsString.getBytes());
            byte[] buf = new byte[1024];
            int b = -1;

            while((b = bis.read(buf)) >-1){
                bos.write(buf,0,b);
            }
            bos.flush();
            result =0;

        }catch (IOException e){
            e.printStackTrace();
        }
        File f = new File(tempFile);
        f.delete();

        return result;
    }
}

One of the key tricks here was using a TypeAdapter for the Gson Json Parser the type that needed to be serialized and de-serialized was an ENUM called SIDE. This has 2 valid options either BUY or SELL.

/*

* Copyright (c) 2020. Ecocrypt.com

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*     http://www.apache.org/licenses/LICENSE-2.0

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

package com.ecocrypt.backtesting.exchange;

import com.google.gson.*;

import java.lang.reflect.Type;

public class SIDETypeAdapter implements JsonSerializer<SIDE>,
        JsonDeserializer<SIDE> {


        public SIDETypeAdapter() {
        }


    @Override    public SIDE deserialize(JsonElement jsonElement, Type type, JsonDeserializationContext jsonDeserializationContext) throws JsonParseException {
        return SIDE.get(jsonElement.getAsString());
    }

    @Override    public JsonElement serialize(SIDE side, Type type, JsonSerializationContext jsonSerializationContext) {
        return new JsonPrimitive(side.toString());
    }
}

Then using the Gson TypeAdapter is done in the GsonBuilder as follows:

package com.ecocrypt.backtesting.exchange;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class Util {

    public static Gson gson(){
        Gson g = new GsonBuilder()
                .setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ")
                .registerTypeAdapter(SIDE.class, new SIDETypeAdapter())
                .create();
        return g;
    }

    public static String yyyyMMdd(Calendar c){
        return yyyyMMdd(c.getTime());
    }

    private static String yyyyMMdd(Date time) {

        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
        return sdf.format(time);

    }
    private static String yyyyMMdd(long l){
        return yyyyMMdd(new Date(l));
    }
}

The SIDE enum is show for completeness:

package com.ecocrypt.backtesting.exchange;

public enum SIDE {
    BUY {
        @Override        public String toString() {
            return "BUY";
        }
    },
    SELL{
        @Override        public String toString() {
            return "SELL";
        }
    };
    public static SIDE get(String s){
        if(s.equalsIgnoreCase("BUY")){
            return BUY;
        }else{
            return SELL;
        }
    }
}

Classic Visitor Pattern in Java

2020-02-06T21:34:00.002-06:00

First let's take a quick look at the classic visitor pattern.
When do you want to use the visitor:

A fixed number of objects that you want to be able to apply operations on.
These objects don't currently have the ability to perform the operations needed.
Limited ability access or change the behavior of the objects.

The basic idea of the visitor pattern is this: Starting with a group of related objects say, Shapes, where these shapes may be squares and circles etc.. which do not know how to calculate their perimeters and you either don't have access to or don't want to code the logic in the shape. Therefore we need a mechanism to calculate the perimeter (or area or other feature) without modifying the original code. However, we do have the good fortune of having each Shape implement an "accept" method which accepts a visitor.

So we develop a concrete "PerimeterShapeVisitor" which knows how to calculate the perimeter for all known shapes. This class does not know how to do anything else. Also this class must implement the special "ShapeVisitor" interface. This allows polymorphism of the java language to select which shape logic needs to be invoked. Key code samples are discussed below. The running code can be found at GIST Classic Visitor
------------------------------------------------------------------------------------------------
Classic Visitor Code

Each shape must implement the Shape interface to "accept" a visitor e.g.
```
public interface Shape {
    void accept(ShapeVisitor v);
}
```

Each ShapeVisitor (e.g. the PerimeterVisitor) must implement the ShapeVisitor

public interface ShapeVisitor {
    void visit(Square s);
    void visit(Circle c);
    void visit(IsoscelesTriangle t);
}

And the Concrete Perimeter Visitor Looks like this:

public class PerimeterVisitor implements ShapeVisitor{

    @Override    public void visit(Square s) {
        double p = s.side()*4;
        System.out.println("Square perimeter: " + p);
    }

    @Override    public void visit(Circle c) {
        double radius = c.radius();
        double p = Math.PI*2*radius;
        System.out.println("Circle perimeter: " + p);

    }

    @Override    public void visit(IsoscelesTriangle t) {
        double base = t.base();
        double height = t.height();
        double p = base+Math.sqrt(base*base + 4*height*height);
        System.out.println("Isosolese Triangle perimeter: " + p);
    }
}

Running the Visitor Test:

public static void main(String[] args){
    List<Shape> shapeList;
    shapeList = new ArrayList<>();

    shapeList.add(new Circle(1));
    shapeList.add(new Square(1));
    shapeList.add(new IsoscelesTriangle(1, 1));
    PerimeterVisitor v = new PerimeterVisitor();
    for (Shape s:shapeList) {
        s.accept(v);
    }

}

Produces the following output:
Circle perimeter: 6.283185307179586
Square perimeter: 4.0
Isosceles Triangle perimeter: 3.23606797749979

SEQUENCE OF EVENTS IN THE VISITOR:

A Shape invokes the accept(v) method passing a visitor associated with whatever operation it would like to perform.
Since Shape is an interface, polymorphism of the language will dynamically bind the "accept(v)" method associated with the concrete shape, e.g. for a Circle, the Circle's accept method will be invoked. This decision is made at run time
The accept method will the invoke the "visit" method of the PerimeterShapeVisitor Class, and the method selected will be the Calculate

Performance of the parallelSort method introduced in Java SE 8.

2020-02-05T14:39:00.000-06:00

Taking a quick look at a feature added to java in SE8. This is a parallel Array sort, and it takes advantage of multiple processors to sort arrays more quickly. The feature is really easy to use, simply invoke Arrays.parallelSort(input);. instead of the old Arrays.sort(input);. That is it. Lets look at a simple performance test with results:

            size %Faster               serial ns      parallel ns
              10 -83.5% Faster ->          1,908            3,502
             100 17.0%  Faster ->          5,496            4,560
            1000 65.3%  Faster ->        149,033           51,768
           10000 5.1%   Faster ->        488,044          463,089
          100000 57.7%  Faster ->      6,153,690        2,601,578
         1000000 56.2%  Faster ->     72,704,992       31,827,891
        10000000 58.2%  Faster ->    855,719,416      357,283,539

Some Notes about this test:

The sort and parallel sort are tested on the exact same Array. An array is generated using the syntactic sugar of $\lambda$ expressions and then duplicated with a System.arrayCopy(...). as

private double[] randomArray(int size) {

    double[] result = new double[size];
    Random randGen = new Random();

    // Use the parallel Set All function to generate this random number quickly.

    Arrays.parallelSetAll(result, value -> {
        return randGen.nextDouble() * 10000;
    });
    return result;
}

The test is run 9 times without recording the result. This is to make sure that the JVM as "warmed up" and the hotspot will not experience a compile pause.
Prior to each sort a System.gc() is invoked to give the JVM a chance to clean up any garbage.

Looking at the results on a 4 core iMac:

Hardware Overview:

Model Name: iMac

Processor Name: Quad-Core Intel Core i5

Processor Speed: 3.2 GHz

Number of Processors: 1

Total Number of Cores: 4

L2 Cache (per Core): 256 KB

L3 Cache: 6 MB

Memory: 32 GB

Based on the above results it is clear that an array must be at least 100 elements in size to overcome the cost of using multiple threads for the sorting, however at 100,000 a consistent cost savings of 50%+ exists.
The gist for this is:

Installing Multiple JVMs on a Mac Manually and Switching Manually with latest Default

2020-02-04T21:17:00.003-06:00

This blog will show you now to install multiple version of java manually on a Mac, and switch between them manually. It will also show how to set and maintain the default java to the "latest" version.

First, Check if there are any version of java installed. I just bought a 2013 iMac on Ebay, and set it up tabula rosa.

iMac:~ $ /usr/libexec/java_home -V

Unable to find any JVMs matching version "(null)".

Matching Java Virtual Machines (0):

Default Java Virtual Machines (0):

No Java runtime present, try --request to install.

Mac OS looks for java in the /Library/Java/JavaVirtualMachines/ directory. Therefore if we download a valid Java JDK, and "copy" the un-archived structure over to that directory, we will see that it works. This is done as follows.

Java 13 is available from Java 13 link - > https://jdk.java.net/13/ or it can obtained via wget with:

iMac:java $ wget https://download.java.net/java/GA/jdk13.0.2/d4173c853231432d94f001e99d882ca7/8/GPL/openjdk-13.0.2_osx-x64_bin.tar.gz

--2020-02-04 19:01:16-- https://download.java.net/java/GA/jdk13.0.2/d4173c853231432d94f001e99d882ca7/8/GPL/openjdk-13.0.2_osx-x64_bin.tar.gz

Resolving download.java.net (download.java.net)... 104.87.12.11

Connecting to download.java.net (download.java.net)|104.87.12.11|:443... connected.

HTTP request sent, awaiting response... 200 OK

Length: 189969691 (181M) [application/x-gzip]

Saving to: ‘openjdk-13.0.2_osx-x64_bin.tar.gz’

openjdk-13.0.2_osx-x64_bin.tar.gz 7%[====> ] 13.50M 254KB/s eta 9m 8s

Once this has been downloaded: it can be extracted and copied or move to the /Library/Java/JavaVirtualMachines/ directory.

Extract with the "tar -xvzf openjdk-13.0.2_osx-x64_bin.tar.gz" which says eXtract Verbose Compressed(z) Filesystem.

$ tar -xvzf openjdk-13.0.2_osx-x64_bin.tar.gz
$ mv jdk-13.0.1.jdk/ /Library/Java/JavaVirtualMachines/

Re-running the /usr/libexec/java_home -V command gives:

$ /usr/libexec/java_home -V

Matching Java Virtual Machines (1):

13.0.1, x86_64: "OpenJDK 13.0.1" /Library/Java/JavaVirtualMachines/jdk-13.0.1.jdk/Contents/Home

/Library/Java/JavaVirtualMachines/jdk-13.0.1.jdk/Contents/Home

And 'java -version' on the command line gives:

$ java -version

openjdk version "13.0.1" 2019-10-15

OpenJDK Runtime Environment (build 13.0.1+9)

OpenJDK 64-Bit Server VM (build 13.0.1+9, mixed mode, sharing)

After downloading and installing several different version of java (which included creating an oracle account, and getting one of the "legacy/archived" version of java from the oracle website) my lib execute for java home looked like this:

$ /usr/libexec/java_home -V

Matching Java Virtual Machines (4):

13.0.1, x86_64: "OpenJDK 13.0.1" /Library/Java/JavaVirtualMachines/jdk-13.0.1.jdk/Contents/Home

11.0.6, x86_64: "Java SE 11.0.6" /Library/Java/JavaVirtualMachines/jdk-11.0.6.jdk/Contents/Home

1.8.0_241, x86_64: "Java SE 8" /Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home

1.7.0_80, x86_64: "Java SE 7" /Library/Java/JavaVirtualMachines/jdk1.7.0_80.jdk/Contents/Home

/Library/Java/JavaVirtualMachines/jdk-13.0.1.jdk/Contents/Home

Now it might make sense to just add some convenience methods to the environment files. Basically this is the step to make it very easy to switch to different version of java on the command line:

PLACE THIS IN YOUR ~/.bash_profile or other startup environment script directory

export JAVA_HOME_7=$(/usr/libexec/java_home -v1.7)

export JAVA_HOME_8=$(/usr/libexec/java_home -v1.8)

#export JAVA_HOME_9=$(/usr/libexec/java_home -v9)

#export JAVA_HOME_10=$(/usr/libexec/java_home -v10)

export JAVA_HOME_11=$(/usr/libexec/java_home -v11)

export JAVA_HOME_13=$(/usr/libexec/java_home -v13)

alias java7='export JAVA_HOME=$JAVA_HOME_7'

alias java8='export JAVA_HOME=$JAVA_HOME_8'

#alias java9='export JAVA_HOME=$JAVA_HOME_9'

#alias java10='export JAVA_HOME=$JAVA_HOME_10'

alias java11='export JAVA_HOME=$JAVA_HOME_11'

#alias java12='export JAVA_HOME=$JAVA_HOME_12'

alias java13='export JAVA_HOME=$JAVA_HOME_13'

#default

java13

Source your newly modified .bash_profile (this only needs to be done once, and not after a login logout...)
$ source ~/.bash_profile
Now switching from java13 to java7 is as easy as typing $ java7 at the command line E.G.

iMac:~ $ java7

iMac:~ $ java -version

java version "1.7.0_80"

Java(TM) SE Runtime Environment (build 1.7.0_80-b15)

Java HotSpot(TM) 64-Bit Server VM (build 24.80-b11, mixed mode)

iMac:~ $ java8

iMac:~ $ java -version

java version "1.8.0_241"

Java(TM) SE Runtime Environment (build 1.8.0_241-b07)

Java HotSpot(TM) 64-Bit Server VM (build 25.241-b07, mixed mode)

iMac:~ $ java11

iMac:~ $ java -version

java version "11.0.6" 2020-01-14 LTS

Java(TM) SE Runtime Environment 18.9 (build 11.0.6+8-LTS)

Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.6+8-LTS, mixed mode)

iMac:~ $ java13

iMac:~ $ java -version

openjdk version "13.0.1" 2019-10-15

OpenJDK Runtime Environment (build 13.0.1+9)

OpenJDK 64-Bit Server VM (build 13.0.1+9, mixed mode, sharing)

Fly Swatter Problem Google Code Jam 2008 Qualifying Round Problem 3

2020-02-03T00:11:00.000-06:00

The Fly Swatter problem was quite challenging.
This solution uses an "Exact" closed form solution.

Basic problem summary: calculate the probability of hitting a fly with a tennis racket.
CodeJam's Detailed statement: Code Jam 2008 Qualifying Round P3

The basic idea is the following:

Divided the Tennis racket into 4 symmetric quadrants
Calculate the area where the fly would be able to safely fly through
Calculate the total Area
Solution 1-safeArea/totalArea is the solution. format and maintain 6 sig figs.

Prior to really diving into this problem there is a bit of Trigonometry that must be programmed. Specifically, we will be required to calculate the area of a "chord" of a circle. For the most part equations of this assume that $Area = f(\theta,r) \stackrel{\bullet}{\equiv} \theta $. However, we will need this in the form $Area = f(x_{1},x_{2},r) \space where \space x_{1} , x_{2} $ are the x-coordinates of the 2 points of the chord. So the Area of the chord in a usable format for this problem becomes: $$ { 1 \over {2}} r^2 ( 2 \arcsin{{l}\over{2r}}) - \sin{(2 \arcsin{l\over{2r}})}$$ where $ l $ is the length of the chord.
Or In Code Calculate the Area of a Chord:

The North-East Case:

$$Area = gap^{2} - {1 \over 2} (xTwo - X_{RIM \space yTwo} ) * (yTwo - X_{RIM \space xTwo}) + ChordArea (X_{RIM \space yTwo},X_{RIM \space xTwo})$$,

West East Case:
$$ Area = gap*(yOne - RIM_{y \space xTwo}) + {{1 \over 2} (RIM_{y \space xOne} - RIM_{y \space xTwo})} + ChordArea (X_{RIM \space xTwo},X_{RIM \space xOne})$$
OR IN CODE In Code Area Calc for West-East Case:

For The North South And West South Cases: the code with picture is self explanatory, see the code at the bottom of the blog or on Git HUB

Mountain Lion Dock Freeze.

2012-10-21T22:00:00.000-05:00

This is quite frustrating, the Mountain Lion Dock Freezes. WAY to often. What do you do when this happens?

SOME OPTIONS:

HARD REBOOT ( not fun...)
killall Dock (reqires access to a terminal)

Because this happens often, a habit has formed to make sure to keep a terminal is always open. Then just switch via the apple in the upper left, and invoke

PROMPT $ killall Dock

Shortest blog post I ever wrote... Just trying to get the word out...

Unique Static Content and Eclipse Non-Consume Regex Glitch

2012-08-29T17:31:00.001-05:00

I discovered a technique to allow infinite cache expire time for images and static content on websites. This technique is highly desirable because image requests and 304 requests consume time and make the user experience poor. The technique is to include a version as follows:

In Fact, in the above example you could be even more sophisticated and include the MD5-checksum or other very unique identifier.
So I cracked open Eclipse to make the REGEX search and replace. The expression I came up with was:

#Search RegEx
# This looks for .jpg, and then does a 
# NON-Consuming match on a word boundary where there is NOT a ?
# For example .jpg" and .jpg' would match, but .jpg?version2 will not
\.jpg(?\b)(?[^\?])
#Replacement
\.jpg?STATIC_CONTENT_VERSION

I proceeded to do the simple search and replace.

To my chagrin, I received the infamous Error:
, "Match string has changed in the file"

Why is this? Well I googled it. It is a know bug with Eclipse and regexes...
Eclipse Bug.

Workaround: well we could use Netbeans, but I choose to go more primitive and use perl. This post will include the generic perl script developed to solve the simple issue and how it was used:

To use, simple type perl findreplace.pl regexSearch regexReplace [0|1]
The 0 is a dryrun, the 1 will really do the replace.

use File::Find;
use File::Basename;

# The inputs:
# directory to start in, findRegex, replacement, dryrun indicator
@DIRS = $ARGV[0];
$patternFind = $ARGV[1];
$patternReplace = $ARGV[2];
$dryrun = $ARGV[3];

#  process a single file (this sub is called from below)
sub processFile{

    $baseN="";
    $dirN="";
    $extN="";
    $linesProcessed = 0;
    $currentFile = $File::Find::name;
    ($baseN,$dirN,$extN) = fileparse($currentFile,'\..*');
    if ($extN eq ".java" || 
        $extN eq ".jsp"  ||
        $extN eq ".properties" ||
        $extN eq ".js" ||
        $extN eq ".css" ){
        # This represents a file that we want to do a search and replace on.
        # print "found java $currentFile :$extN:$baseN:$dirN:\n";
    }else{
        # print "\nRETURNING: $currentFile\n\n";
        return;
    }

    $currentBaseName = $_;

    # OPEN THE FILE READ ONLY.
    open FILE, $currentBaseName;
    $modify= 0;
    # DETERMINE IF THE FILE CONTAINS A MATCH
    while($line =){
        if($line =~ /$patternFind/){
            $modify++
        }
    }
    close FILE;
    if($modify==0){
        # THERE WAS NO REGEX MATCH, SO EXIT.
        return;
    }

    # NO IT's not the evil number, 
    # it means set to global read/write in unix.
    # required for TFS integration.
    chmod 0666, $currentBaseName;

    open (FILE, "+< $currentBaseName")  or die "can't read $currentFile $!";
    $out = '';
    while(){
        if($_ =~ /$patternFind/){
            $linesProcessed++;
        print "\tReplace: $_\n";
            s/$patternFind/$patternReplace/eg;
        print "\tWith: $_\n";
        }

        $out .=$_;
    }

    if($dryrun==1){

        seek(FILE,0,0) or die "can't seek to start of $currentFile $!";
        print FILE $out or die "cant't print $currentFile $!";
        truncate(FILE, tell(FILE))  or die "can't truncate $currentFile: $!";
        close (FILE)         or die "can't close $currentFile: $!";

    }

    print "File:$baseN$extN :From ->:$dirN\n";
    print "Lines Changed: $linesProcessed\n";
    print "___________________________________________________\n";
}
find (\&processFile, @DIRS);

hope you find this useful!

Eclipse/NetBeans Multi Line Search and Replace Across Files

2012-06-01T13:16:00.000-05:00

We all know System.out.println statements are not good for performance and clutter logs. We should use a logger instead. Loggers allow for the control of logging levels. How do you replace these System.outs in a large project? Here are the steps used recently:

Come up with a good REGular EXspresion (REGEX), for matching your desired code.
Come up with your replacement regex and capture user.
Ensure that your code compiles and inspect your changes.

In this case we want to replace the following:

package com.ecokrypt...

public class ToManySystemOuts {

    System.out.println("Single Line System.out.println");


    System.out.println("Rare multiline " +
           " System.out.println ");

}

We need to find a REGEX that will match both of these cases. There are several ways to do any REGEX, but a solution that is easy to understand that will work is:

   (?s)System.out.println(\(([^;]+?)\));

We have to dissect what this is saying to understand a couple of subtleties:

(?s) - indicates that we search past line feeds. Without this we will not match the second case because the line feed would cause the REGEX to not match at all.
System.out.println - matches the exact phrase
($([^;]+?)$) - is very complicated, and will take time before you can read this. A technique that typically works is to read it inside out. Trying that out:

[^;]+ - look for anything that is NOT a ';' (semicolon). the + is saying that you have to match at least 1, and there is no limit to how many characters you can match.
([^;]+?) - Has a real subtlety to it, Regexes have an ability to be greedy, or lazy. A greedy regex will match the largest region it can. A lazy regex will match the smallest area it can. It will take time to figure out when to use which, but the basic advice given here is ALWAYS try to use lazy. Only use greedy if you really need it. This REGEX is obviously lazy, how can you tell? Think about it a bit.

the ? indicates that you are going to look for the next sequence imediately after.
the (...) indicates you are going to "capture" whatever you find presumably for later use.
therefore the ( ) are not matched but are just part of the regex capture syntax.
So the answer is: if the ? is inside the capture group e.g. (...?) the matching is lazy; if the ? is outside of the capture group, the matching is greedy e.g. (...)?

$([^;]+?)$ - says, adds the $...$ to the previous the \ is an escape character and says match a ( and a ), don't create another capture group.
($...$) - says, now add another capture group containing everything inside the literals ( ).

; the semicolon at the end says match a literal semicolon.

That is pretty much all there is to it. Look at the following REGEX, which might be a common mistake and see if you can figure out why it won't work. Guess what it will match. (HINT thing about greedy vs lazy).

   (?s)System.out.println(\(([^;]+)?\));

Now that we have our matching REGEX, we need to get our replacement REGEX:

   System.out.println$1;

This is much simpler, it says: replace the above match, with logger.debug$1; where $1 is inclusive the literal (...). e.g. the braces and everything inside of them.

How do we do this inside of Eclipse or NetBeans?
I find NetBeans to be much nicer in some respects, and not so nice in others.

NetBeans in File Search Replace

This is the netbeans view, it uses the space very nicely and there is NO POPUPS... You really have to like the ergonomics of NetBeans. The search is dynamic and nicely highlighted so you can see the search as you go.

NetBeans Replace Across All Files
USE CRTL-H for a shortcut to this Menu.

NetBeans Confirmation Dialog

Eclipse:

The Eclipse Search Dialog. (Allows you to select scope)

Creating A Java Applet to Run in Chrome, Firefox, IE, Opera, and Safari

2012-01-06T07:21:00.000-06:00

Just throwing together a really quick page to allow people to grab a code snipit
showing how to write html to allow an applet to be embedded in a page, such that it works in Chrome, Firefox, IE, Opera and Safari.

The following should work.
I would love comments on better ideas.

Running 47906Proxy as an Applet

2011-10-19T17:47:00.002-05:00

This article describes running the 47906Proxy as an Applet:

Brief History of the 47906Proxy: The proxy was developed initially as a port forwarder, or simply a forwarding proxy. What is a forwarder proxy, and how is it used? Three use cases are included below the 47906Proxy demonstration applet (the use cases include Tunneling, Application level Protocol Sniffing, and Network Latency Trending). In addition a code snip-it has been included below the proxy to allow for a cut and paste usage on your website.

USE CASE 1:

Firewall hopping.

Firewall hopping is some times called tunneling, this will allow an application to access a port on a remote machine behind a firewall, without the need or requirement to poke a hole in the firewall. Additionally, forwarding proxies can add additional checking and validation to ensure that the individual trying to tunnel has the privileges and rights to do that.

USE CASE 2:

Protocol Sniffing

This allows a very high level of stream sniffing, or application layer protocol sniffing. Frequently this is much more desirable than low level packet capture sniffing.

USE CASE 3:

Performance Monitoring

This allows for data flow rate analysis, and latency analysis at a much higher level than a packet sniffer.

Software Entrepreneur Round-Table

2011-08-24T19:11:00.001-05:00

What: A Software Entrepreneur Round-Table
When: October 24 from 6:30 PM - 8:30 PM CST
Venue: TBD (Skype/google-voice/ tele-video conference)
Who: We are looking for a global perspective, In particular looking for Entrepreneur's from China, India, Europe/Russia, US and South America
Format: Informal Moderated Discussion.
Language: English

Goal group size 6-10 Entrepreneurs or perspective entrepreneurs:

Agenda:
1. Welcome and Introductions
2. Discussion Rules
3. Each Idea is presented and Brainstormed (semi open)
4. 10/4 voting on difficulty, competition, and feasibility
5. Exchange of contact info
6. Business plan partner assignment
7. Followups

To Sign Up, Email: October.RoundTable@ecocrypt.com
Include: your name
your country
your phone
your email

You will receive either a phone call, or an email within 72 hours.

Ecocrypt's RegEx Testing Applet and Java-Regex Source Generator

2011-05-11T19:35:00.000-05:00

This is the Discussion Board For EcoCrypt's RegEx Testing Applet.

Feel free to use this, or bookmark the actual link http://www.ecocrypt.com/regex
*Features:

Test your regex pattern against text input.
Generate the Java source code for the regex matcher.
Run your regex against a file on your local harddrive.

Please Leave Comments! Comments Can Be Related To Wish List, Usability, Or Other RegEx Thoughts.

Creating an SVN repository on Bluehost

2011-04-29T23:57:00.000-05:00

Motivation:
There are many free svn repository providers. If you are an individual developer, you may choose to use one of those. Some have the restriction that repository is publicly accessible such as google code and sourceforge, while others keep the repository private such as projectlocker and sliksvn. After reading the license agreements and contracts, I decided to maintain my own repository.

Warning:
This discusses how to set up and configured a svn repository on BlueHost using a windows 7 as the client machine: This setup is not for the faint of heart. It requires modifying configuration settings, compiling source code with multiple complex config options, generating ssh keys, setting up ssh, and properly configuring the windows environment. (NOTE: All of these steps can be followed for linux/bsd/mac. Slight modifications to the commands may be required, such as using forward-slashes for paths instead of back-slashes; using : for path separators instead of ';'; and other OS specific idiosyncrasies)

Quick Overview:

Install SSH on the client
Setup SSH Keys (you will have to contact bluehost directly to get permission to use SSH to access your server)
Install an SVN Client
Compile and Install the SVN Server from source on your bluehost box.
Setup an ssh-svn service bridge (sshsvnserve)
Instruct svn to use the service bridge when connecting to your repo.
Using the repository.
Properly backing up the repository (don't trust bluehost to back up the repository for you).

Getting Started:

Install SSH On Windows 7 (or any other version of windows)

I use mingw (which is minimal gnu for windows). This is an excellent package, and does not have all the complexities of cygwin. However, cygwin might work just fine. I don't use it because it tends to mess up gmake/gnu's make program.

Download and install mingw from http://www.mingw.org/
Assuming you installed at c:\MinGW, then add C:\MinGW\msys\1.0\bin to your system path environment variable.
Confirm all is working by typing svn -v from any directory on your box, you should get:

C:\>ssh -v

OpenSSH_5.4p1, OpenSSL 1.0.0 29 Mar 2010
usage: ssh [-1246AaCfgKkMNnqsTtVvXxYy] [-b bind_address] [-c cipher_spec]
           [-D [bind_address:]port] [-e escape_char] [-F configfile]
           [-I pkcs11] [-i identity_file]
           [-L [bind_address:]port:host:hostport]
           [-l login_name] [-m mac_spec] [-O ctl_cmd] [-o option] [-p port]
           [-R [bind_address:]port:host:hostport] [-S ctl_path]
           [-W host:port] [-w local_tun[:remote_tun]]
           [user@]hostname [command]

Congrats! step 1 is done

Setup SSH Keys
SSH keys allow you to login to your account on BlueHost without the need for a password. It works by storing a private key on your computer, and you upload a public key to your account on the BlueHost box. You can then login using ssh, or interact using scp without specifying a password, by specifying the ssh private key file. The public and private keys are asymmetric keys. This means that which ever key is used to encrypt the data, the other key must be used to decrypt data. Authentication is accomplished by providing a challenge to the requesting client.
Assuming Step 1 was completed successfully, the ssh-keygen program should be in your path.

pick a directory to store your public and private key, and switch to that directory
A good choice would be -> c:\Users\[Windows User]\.ssh
Generate the public and private key, there are many options, choosing all defaults (with the exception of the file name) is typically good.

C:\Users\[My Account]\.ssh>ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (//.ssh/id_rsa): id_rsa_svn
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in id_rsa_svn.
Your public key has been saved in id_rsa_svn.pub.
The key fingerprint is:
04:a3:1a:b7:5d:6f:29:39:bc:30:a3:c7:c6:b0:2f:49 [My Account]@[mycomputer's name]
The key's randomart image is:
+--[ RSA 2048]----+
|      o          |
|     . o         |
|  . o   o        |
|   + o + o .     |
|  . o = S +      |
|    E* + =       |
|   .o.= .        |
|    o+           |
|     ..          |
+-----------------+

Test out your SSH Key

upload the public key to the bluehost server, KEEP the private key private! This is important because this protects the bluehost account from unauthorized access.
Install the key in your authorized_keys file
Test the access.

From your windows box:

C:\Users\[Windows User]\.ssh>ls
id_rsa  id_rsa.pub  id_rsa_svn  id_rsa_svn.pub

C:\Users\[Windows User]\.ssh>scp id_rsa_svn.pub [bluehost account]@[bluehost machine]:~/.ssh
[bluehost account]@[bluehost machine]'s password:
id_rsa_svn.pub                                                                                            100%  401     0.4KB/s   00:00

You will now need to log into the bluehost box, and manually add the public key to the authorized_keys file. To do this, log on to your bluehost account, and follow the following steps.

[bluehost account]@[bluehost machine] [~]# cd .ssh
[bluehost account]@[bluehost machine] [~/.ssh]# dir
./  ../  authorized_keys2  environment  id_rsa_svn.pub
[bluehost account]@[bluehost machine] [~/.ssh]# cat id_rsa_svn.pub >> authorized_keys2

NOTE to see the changed file:
[~/.ssh]# cat authorized_keys2

Finally From the windows box, test out the key to make sure that it works:

C:\>ssh -i "c:\Users\[Windows User]\.ssh\id_rsa_svn" [bluehost account]@[bluehost machine]
Last login: Thu Apr 28 17:08:06 2011 from 32.178.80.204
[bluehost account]@[bluehost machine] [~]#

Install An SVN client
Any svn client should do the job, SlikSVN seems to be a good distribution. However, many others will do the job. SlikSvn comes as a standard windows installer, it will typically add the subversion client tools to your path. Once it is installed on your windows box, test to make sure the svn.exe file is executable from any directory.

C:\>svn --version
svn, version 1.6.16 (SlikSvn/1.6.16) X64
   compiled Mar  3 2011, 22:35:47

Copyright (C) 2000-2009 CollabNet.
Subversion is open source software, see http://subversion.apache.org/
This product includes software developed by CollabNet (http://www.Collab.Net/).

The following repository access (RA) modules are available:

* ra_neon : Module for accessing a repository via WebDAV protocol using Neon.
  - handles 'http' scheme
  - handles 'https' scheme
* ra_svn : Module for accessing a repository using the svn network protocol.
  - with Cyrus SASL authentication
  - handles 'svn' scheme
* ra_local : Module for accessing a repository on local disk.
  - handles 'file' scheme
* ra_serf : Module for accessing a repository via WebDAV protocol using serf.
  - handles 'http' scheme
  - handles 'https' scheme

Compiling SVN Server on BlueHost

Download the latest version of Subversion from sourceforge.
copy it up to the BlueHost Account
configure the compilation process for BlueHost
make the components
install the svn server and libraries

I will outline these steps in the following shell capture. Note that config and compiling take several minutes each.

[~]# cd src
[~/src]# cd subversion-1.6.16
[~/src/subversion-1.6.16]# ./configure --prefix=$HOME/svn/bin --without-apxs --exec-prefix=$HOME/svn/lib --disable-mod-activation
[~/src/subversion-1.6.16]# nohup make &
[~/src/subversion-1.6.16]# tail -f nohup.out
[~/src/subversion-1.6.16]# make install

Subversion server is now installed on BlueHost. At this point, it must be tested.
The following shell snippet shows the testing expectation:

[~]# cd svn/lib/bin
[~/svn/lib/bin]# ./svnserve --version
svnserve, version 1.6.16 (r1073529)
   compiled Apr 27 2011, 17:27:09

Copyright (C) 2000-2009 CollabNet.
Subversion is open source software, see http://subversion.apache.org/
This product includes software developed by CollabNet (http://www.Collab.Net/).

The following repository back-end (FS) modules are available:

* fs_fs : Module for working with a plain file (FSFS) repository.

Cyrus SASL authentication is available.

Setting up an ssh-svn service bridge:
In this step a bridge will be set up. The purpose of this bridge will be two things:

Set up enough of an environment to execute svnserve command (by default and for security purposes bluehost disables shells and environments for remote logins)
Instruct ssh to invoke a temporary service immediately on connect. (this service will of course be the svnserve command which serves content from an svn repository)

Log into your BlueHost machine, change to the .ssh directory, open the authorized_keys2 file with a text editor, vi or pico should do. Find the public key entry that was added to this file in the step above. This key is going to be modified by adding some instructions to the front of the key. the instructions to be added are: command="/home1/[your bluehost account]/sshsvnserve -t" see the code snippet below for an example of what things should look like:

command="/home1/[your bluehost account]/sshsvnserve -t" ssh-rsa AAAABCCCCCCDDDDDDDD3NzaC1yc2EAAAADAQABAAABAQDJezPXNZb8rls8GrxH46zZwUO6vm1bkgxD2jma4RJMlXH0ADTDsQ2PGZAW80hVamojBsKGUN8zYH2i3LiEYiNSqL2d6mvFZAxIGH4mxhQQZdImyIWEnAK5a9HL9SQlIRnKa0ZEEsi/KWmiyB/gOXtKxxW7aU9KIsk2mjG0UZfmRHE4OhvXQqguAZCScOHh/WDRXiC2t2WbmfSXJK7KNz2sjla8Y62Z+u3Lg0m4SlmNqLgllh+tY0Nbxd623sJSQVqNwutPPMd1IhybjQskXUv8OlSmVepkhnGpSteRIzI99MocX8LzrZefHSaPsyMeHri52VzTb0
3 [windows usr]@[windows machine name]

The only thing added is the first command=..... up to the 'ssh-rsa' of course modified to match your account.

Now create the sshsvnserve shell script. This is a very simple shell script. Switch back to the home directory on the bluehost machine, and create a file with the following content. Note that you will have to change this file to executable before it can be used.

#!/bin/sh
/home1/[your bluehost account]/svn/lib/bin/svnserve $*

Instruct svn to use the service bridge when connecting to your repo.
This is done by adding an ssh directive to your tunnels command. On the windows box, create a subversion config file as bellow.

C:\Users\[Windows Account]\.subversion>cat config


[tunnels]
ssh = ssh -i "c:\\Users\\[Windows Account]\\.ssh\\id_rsa_svn"

USING your new repository:

C:\repos>svn --config-dir="c:\Users\[Your Windows Account]\.subversion" co svn+ssh://[your bluehost account]@[your bluehost machine/ip]/home1/[your bluehost account]/repos

Using the repository
The repository can be used by simply making sure that the --config-dir option is specified, and points to the directory that contains your config file with the [tunnels] entry.

Backing up the Repository:
Assuming that you are using BlueHost for a single user or very small number of users, you can simply create a synchronized repository on your local machine. The steps will be outlined in a code snippet block, with comments.

#  First create the repository.
C:\repos>svnadmin create .

#  Modify the hooks so the repos can accept
#  backup requests from other repositories.
C:\repos>cd hooks
C:\repos\hooks>echo exit 0 > pre-revprop-change.bat
C:\repos\hooks>cat pre-revprop-change.bat
exit 0

# 
C:\repos>svnsync initialize file:///repos svn+ssh://[bluehost caccount]@[bluehost machine]/home1/[bluehost account]/repos --config-dir="c:\Users\[Windows Account]\.subversion"
Copied properties for revision 0.

C:\repos>svnsync synchronize file:///repos --config-dir="c:\Users\[Windows Account]\.subversion"
Committed revision 1.
Copied properties for revision 1.
Committed revision 2.
Copied properties for revision 2.
Transmitting file data .......................................................................
..............................................................................................
...........
Committed revision 3.
Copied properties for revision 3.
Transmitting file data .......................................................................
..............................................................................................
...
Committed revision 4.
Copied properties for revision 4.
Transmitting file data .

Python - Insertion Sort Impl

2011-04-03T22:46:00.000-05:00

This article will discuss a simple insertion sort algorithm for python.
See ALL Python postings | Insertion Sort By Language Java Scala Go C++ Python Perl

Overview of the Insertion Sort Algorithm
Insertion sort is one of the most natural wayTs of sorting a collection of comparable items. The reason it is one of the most natural ways is because it is the way most people will sort physical items. For example each year (about this time) I will sort all 12 of my previous years phone bills, gas bills, etc... The algorithm used to sort them is to place the first one in stack. Then the second one is compared to the first one to see if it goes in front of or behind the first one. The third one is then compared to each if the two sorted items to determine where it fits in. This procedure continues until all 12 bills are in the pile. Once all 12 bills are in the pile it is sorted. I happen to sort form oldest to newest, my spouse does it the other way newest to oldest.

Applying this concept to a collection of objects in a computer is fundamentally the same. The algorithm dictates that one will iterate over a collection of elements in an unsorted list 1 at a time, and place that item into it's correct location in a sorted list.

If the collection of objects to sort is n, insertion sort will take at most $O(n^2)$ operations to perform the sort, it will take on average $\frac{1}{2} O(n^2) = O(n^2)$, and in the best case senario will take $O(n)$ operations.

Questions:

1. What would be the initial characteristics of a list that took the worst case order $O(n^2)$ to sort?
2. What would be the initial characteristics of a list that took the best case order $O(n)$ to sort?

About the Python Solution:
In python this solution relied a bit on creativity. The solution is clearly not $O(n^2)$, however it may take a bit to understand why. The reason lies in the fact that python does not have a linked list that allows insert at a given point in the list. Therefore, to simulate that behavior, this solution rotates the list until it cat append to the left side of the list, and then rotates back. This ensures that the order is correct. What would be the big O of this solution assuming that each rotation is O(n)? Some additional inline comments have been included.

If you have a question about the solution (or feel it should be improved) please leave a comment. All comments are moderated and posted with your name/Identification so please be professional and straight forward. Python Solution:

#!/opt/python
from collections import deque
import random

dq = deque()
for i in range(20):
    dq.append(random.randrange(1001))

for elem in dq:
    print(elem)

sortedQueue = deque()
j=int(0)
k=int(0)
for elem in dq:


    for sortedElem in sortedQueue :
        if elem>sortedElem:
            sortedQueue.rotate(-j)
            sortedQueue.appendleft(elem)
            sortedQueue.rotate(j)
            k=1+k
            break
        j=j+1
    if (k == 0):
        sortedQueue.append(elem)
    else:
        k=0
    j=0

print (sortedQueue)

Answers: 1. The best case senario would be order: $O(n)$ 2. The worst case senario would be order: $O(n^{2})$golang postings

C++ - Insertion Sort Implementation w/ Make file Introduction

2011-04-01T18:46:00.000-05:00

This article will discuss a simple insertion sort algorithm in C++. Unlike any of the other languages in this series on the insertion sort algorithm. C++ has for more caveats and options. While the algorithm is exactly the same the implementation details are filled with pitfalls.
See ALL C++ postings | Insertion Sort By Language Java Scala Go C++ Python Perl

Overview of the Insertion Sort Algorithm
Insertion sort is one of the most natural ways of sorting a collection of comparable items. The reason it is one of the most natural ways is because it is the way most people will sort physical items. For example each year (about this time) I will sort all 12 of my previous years phone bills, gas bills, etc... The algorithm used to sort them is to place the first one in stack. Then the second one is compared to the first one to see if it goes in front of or behind the first one. The third one is then compared to each if the two sorted items to determine where it fits in. This procedure continues until all 12 bills are in the pile. Once all 12 bills are in the pile it is sorted. I happen to sort form oldest to newest, my spouse does it the other way newest to oldest.

Applying this concept to a collection of objects in a computer is fundamentally the same. The algorithm dictates that one will iterate over a collection of elements in an unsorted list 1 at a time, and place that item into it's correct location in a sorted list.

If the collection of objects to sort is n, insertion sort will take at most $O(n^2)$ operations to perform the sort, it will take on average $\frac{1}{2} O(n^2) = O(n^2)$, and in the best case senario will take $O(n)$ operations.

Questions:

1. What would be the initial characteristics of a list that took the worst case order $O(n^2)$ to sort?
2. What would be the initial characteristics of a list that took the best case order $O(n)$ to sort?

About the C++ Solution:
There are several caveats to the C++ solution. Therefore the source file will simply be discussed from top to bottom, with each decision discussed in turn.

Imports: The first thing to notice is the choice of the imports, this solution imports the iostream, list, and cstdlib.

The iostream should be familiar as it is used for I/O.
The list chosen here is from the STL of C++ and is included with the #import <list> directive.
The cstdlib is imported to expose the rand function which is a sudo random number generator.

using namespace std - this allows reference without the need for adding std:: to methods or objects included from std libraries.
Forward Declarations- C++ requires knowledge of all methods and classes before they are used. That means that the compiler must know what each class/methods signature is before first use. (see inline comment)
Pointers Vs Automatics - In this simple example, two lists of ints are created, the unsorted list, and the sorted list. For pedagogical purposes, one was created on the heap, and the other as an "automatic" on the stack. Heap allocated objects must be explicitly freed, or there might be a memory leak. In C++ malloc and free go together, and new/delete go together, where delete releases the memory back to the operating system. Objects that are stack allocated (created without a call to new or malloc/calloc) will be automatically released once the object goes out of scope. Note that it might be possible to blow your stack if you allocate to many automatics.
Iterators - This code example is using the concept of a C++ STL iterator. The concept of an iterator actually warrants multiple posts. Basically from a very simplistic point of view, an iterator will visit each member of the list in turn.

The code has comments that are non-verbose, and useful. Reading the code and comments along with compiling and running the code will help in the understanding of this exercise. If you have a question about the solution (or feel it should be improved) please leave a comment. All comments are moderated and posted with your name/Identification so please be professional and straight forward.
C++ Solution:

The make file:
The make file is presented twice, once with inline comments, and once without. Make files have many interesting caveats that may make direct cutting and pasting of the file difficult, but I will explain.
in a make file, targets are the commands that can be executed. Each target line contains instructions to be carried out. The instruction lines are on the line(s) immediately following the target line. Each target knows it's instructions ONLY by looking for the consecutive lines that immediately follow it, AND are indented with a single TAB '\t' character. Therefore, if you text editor converts tabs to spaces or something like that, it will mangle the make file because the tab characters are significant and have meaning.

first without comments, then with comments for reference:

#--------------------------------------
#
#  Copyright (c) 2011 EcoCrypt.com 
# 
#--------------------------------------

CPP=g++

MAIN=InsertionSort

.SUFFIXES : .exe .cpp

ifeq (${OS},Windows_NT)
EXES=${MAIN}.exe
RM=del /S 
else
EXES=${MAIN}
RM=rm -f # implicitly defined on unix
endif

ALL: ${EXES}

.cpp.exe: 
 echo ${CPP} ${DIRECTIVES} $? -o $@ 
 ${CPP} ${DIRECTIVES} $? -o $@ 

clean:
 ${RM} ${EXES}

Find below the make file with comments:

#--------------------------------------
#
#  Copyright (c) 2011 EcoCrypt.com 
# 
#--------------------------------------

#---------------------------------------
#  Set your compiler
#  On Windows Microsoftt compiler:
#  (i.e. CPP=cl)
#  On Linux, GUN compiler:
#  CPP=g++
#  On Windows MinGW (Minimal GNU for Windows):
#  CPP=g++.exe
#

CPP=g++
#CPP=cl.exe

#  The name of the main output
MAIN=InsertionSort

#  WE have to pass in VC98 and -GX if the compiler
#  is the cl compiler from Microsoft.
ifeq ($(CPP),cl.exe)
DIRECTIVES= -DVC98 -GX
else
endif

.SUFFIXES : .exe .cpp
#---------------------------------------
#  The windows version will contain a .exe
#  extention for each file.
#
#  List the executables.
#  here we have 2 mains that we 
#  will make: test and greetings.
#
#  Also redefine the implicit RM var.
ifeq (${OS},Windows_NT)
EXES=${MAIN}.exe
RM=del /S 
else
EXES=${MAIN}
RM=rm -f # implicitly defined on unix
endif

#---------------------------------------
#  The first target will create all
#  the EXES and recreate any that are 
#  out of Date.
#
#  This is also important because it is 
#  the default target, if you just invoke
#  make from the command like, the first 
#  dependency line becomes the default target.
#
ALL: ${EXES}

#---------------------------------------
#  Suffix rules are powerful and cryptic.
#  This states, for any target with no  (or .exe on windows)
#  suffix, look for a like named file with
#  an extension of .cpp, and perform the command
#  
#  (e.g.  for a file/dependecy named 'test.exe'
#         look for test.cpp, and perform
#         g++ test.cpp -o test.exe)
.cpp.exe: 
 echo ${CPP} ${DIRECTIVES} $? -o $@ 
 ${CPP} ${DIRECTIVES} $? -o $@ 

#---------------------------------------
#  clean the targets so you can force a 
#  rebuild

clean:
 ${RM} ${EXES}

Common Issues:
Forgetting to add the "using namespace std"
This is a common issue because older C++ books did not discuss this as it was added to C++ some time after the ansi standard was initially finalized.
Typically Error:

EcoCryptCppExamples\src\InsertionSort % make
echo g++  InsertionSort.cpp -o InsertionSort.exe
g++  InsertionSort.cpp -o InsertionSort.exe
g++  InsertionSort.cpp -o InsertionSort.exe
InsertionSort.cpp: In function 'void printList(std::list)':
InsertionSort.cpp:57:48: error: 'endl' was not declared in this scope
make: *** [InsertionSort.exe] Error 1

Leaving off one of the import statements. This demonstrates the error if the cstdlib is not imported, which defines the rand and srand functions.

EcoCryptCppExamples\src\InsertionSort % make
echo g++  InsertionSort.cpp -o InsertionSort.exe
g++  InsertionSort.cpp -o InsertionSort.exe
g++  InsertionSort.cpp -o InsertionSort.exe
InsertionSort.cpp: In function 'void printList(std::list)':
InsertionSort.cpp:57:48: error: 'endl' was not declared in this scope
make: *** [InsertionSort.exe] Error 1

The make file is missing key tabs:

C:\47906Proxy\EcoCryptCppExamples\src\InsertionSort>make
Makefile:70: *** missing separator.  Stop.

Answers: 1. The best case senario would be order: $O(n)$ 2. The worst case senario would be order: $O(n^{2})$golang postings

GoLang - Insertion Sort Implimentaion w/ google go

2011-03-26T15:32:00.004-05:00

This article will discuss a simple insertion sort algorithm in golang (google go).
See ALL golang interest postings | Insertion Sort By Language Java Scala Go Python Perl

Overview of the Insertion Sort Algorithm
Insertion sort is one of the most natural wayTs of sorting a collection of comparable items. The reason it is one of the most natural ways is because it is the way most people will sort physical items. For example each year (about this time) I will sort all 12 of my previous years phone bills, gas bills, etc... The algorithm used to sort them is to place the first one in stack. Then the second one is compared to the first one to see if it goes in front of or behind the first one. The third one is then compared to each if the two sorted items to determine where it fits in. This procedure continues until all 12 bills are in the pile. Once all 12 bills are in the pile it is sorted. I happen to sort form oldest to newest, my spouse does it the other way newest to oldest.

Applying this concept to a collection of objects in a computer is fundamentally the same. The algorithm dictates that one will iterate over a collection of elements in an unsorted list 1 at a time, and place that item into it's correct location in a sorted list.

If the collection of objects to sort is n, insertion sort will take at most $O(n^2)$ operations to perform the sort, it will take on average $\frac{1}{2} O(n^2) = O(n^2)$, and in the best case senario will take $O(n)$ operations.

Questions:

1. What would be the initial characteristics of a list that took the worst case order $O(n^2)$ to sort?
2. What would be the initial characteristics of a list that took the best case order $O(n)$ to sort?

About the GoLang Solution:
Inline comments have been added to the code to discuss some of the syntax and code structure.
If you have a question about the solution (or feel it should be improved) please leave a comment. All comments are moderated and posted with your name/Identification so please be professional and straight forward.
GoLang Solution:

package main

/*------------------------------------------------------------------------------
  Copyright (c) 2011 ecocrypt.com

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the spe\]cific language governing permissions and
  limitations under the License.
-----------------------------------------------------------------------------*/
import fmt "fmt"  
import "container/list" 
import "rand"

//  The main entry point.
func main() {
    // create a list of integers randomly ordered.
    var  randomOrderedList = createRandomUnsortedList() 

    //  Perform the insertion sort.
    //  return a new sorted list.
    var sortedList = insertionSort(randomOrderedList)


    //  display the list to standard out.
    displayListToStandardOut(sortedList) 

}


//  private function takes unsortedList, returns sortedList
func insertionSort(unsortedList *list.List) (sortedList *list.List){
    sortedList = list.New()
    for e :=unsortedList.Front();e!=nil; e=e.Next() {
        var found = 0
        for s := sortedList.Front();s!=nil;s=s.Next(){
            if(e.Value.(int)>s.Value.(int)){
                found=1
                sortedList.InsertBefore(e.Value,s)
                s=sortedList.Back()
            }
        }
        if(found==0){
            sortedList.PushBack(e.Value)
        }
    }
    return sortedList
}


//  private method displays the lList to standard out.
func displayListToStandardOut(lList *list.List) {
    counter := 0
    for y :=lList.Front();y!=nil; y=y.Next() {
        counter += 1
        fmt.Printf("%d -> %d\n",counter,y.Value)
    }
}

// private method returns lList
func createRandomUnsortedList() (lList *list.List) {
    //  Create a New Random Generator from a Random Source
    //  with a seed of 10.
        var r = rand.New(rand.NewSource(10))

    //  create a list of random integers.
    lList = list.New()
    for i :=0; i<15; i=i + 1 {
        lList.PushFront(r.Int())
    }
    return lList
}

Answers: 1. The best case senario would be order: $O(n)$ 2. The worst case senario would be order: $O(n^{2})$golang postings

Scala - Insertion Sort Implementation

2011-03-22T23:16:00.003-05:00

This article will discuss a simple insertion sort algorithm in Scala.
See ALL Scala postings | Insertion Sort By Language Java Scala Go Python Perl

Overview of the Insertion Sort Algorithm
Insertion sort is one of the most natural ways of sorting a collection of comparable items. The reason it is one of the most natural ways is because it is the way most people will sort physical items. For example each year (about this time) I will sort all 12 of my previous years phone bills, gas bills, etc... The algorithm used to sort them is to place the first one in stack. Then the second one is compared to the first one to see if it goes in front of or behind the first one. The third one is then compared to each if the two sorted items to determine where it fits in. This procedure continues until all 12 bills are in the pile. Once all 12 bills are in the pile it is sorted. I happen to sort form oldest to newest, my spouse does it the other way newest to oldest.

Applying this concept to a collection of objects in a computer is fundamentally the same. The algorithm dictates that one will iterate over a collection of elements in an unsorted list 1 at a time, and place that item into it's correct location in a sorted list.

If the collection of objects to sort is n, insertion sort will take at most $O(n^2)$ operations to perform the sort, it will take on average $\frac{1}{2} O(n^2) = O(n^2)$, and in the best case senario will take $O(n)$ operations.

Questions:

1. What would be the initial characteristics of a list that took the worst case order $O(n^2)$ to sort?
2. What would be the initial characteristics of a list that took the best case order $O(n)$ to sort?

About the Scala Solution:
Inline comments have been added to the code to discuss some of the syntax and code structure.
If you have a question about the solution (or feel it should be improved) please leave a comment. All comments are moderated and posted with your name/Identification so please be professional and straight forward.
Scala Solution:

package com.ecocrypt.scala.helloworld.com.ecocrypt.scala.algorithms.sort

import java.util.LinkedList

/*------------------------------------------------------------------------------
  Copyright (c) 2011 ecocrypt.com

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the spe\]cific language governing permissions and
  limitations under the License.
-----------------------------------------------------------------------------*/

object InsertionSort {
    var flag = 0
    var counter = 0


    def sort(unsortedList: List[Int]): LinkedList[Int] = {
        // Start with an empty LinkedList.
        // as items are added to the list, they will be
        // placed in sorted order.
        var sorted = new LinkedList[Int]()

        // Iterate over the unsorted list one Item at a time.
        for (currentItem <- unsortedList) {
            flag = 0
            counter = 0;

            //------------------------------------------------------------------------------------
            //  Scala allows us to define helper functions with scope inside of other functions.
            //        this creates some very interesting closure situation.
            //        More on this in later code samples
            //------------------------------------------------------------------------------------
            def checkRecordToRightAndInsertIfLocationFound(itemRightOfCurrentPostion: Int): Int = {
                if (itemRightOfCurrentPostion > currentItem) {
                    // flag is a var defined in an enclosed scope.
                    flag = 1
                    if (counter < 0) {
                        sorted.addFirst(currentItem)
                    } else {
                        sorted.add(counter, currentItem);
                    }
                }
                //  this is the return val of this method.
                flag
            }


            do {
                if (counter == sorted.size) {
                    sorted.addLast(currentItem)
                    flag = 1
                } else {
                    var itemRightOfCurrentPostion = sorted.get(counter)
                    flag = checkRecordToRightAndInsertIfLocationFound(itemRightOfCurrentPostion)
                }
                counter = counter + 1
            } while (flag == 0)
        }
        return sorted
    }
}

//  Here we use an application to serve as the entry point.
object EntryPointForInsertionSortExample extends Application {
    val randomOrderedList = List.fill(10)(scala.util.Random.nextInt(1000))
    println("unsorted List : " + randomOrderedList)
    val sortedList = InsertionSort.sort(randomOrderedList)
    println("sorted List : " + sortedList)
}

Answers:
1. The best case senario would be order: $O(n)$
2. The worst case senario would be order: $O(n^{2})$

Java - Insertion Sort Implementation and discussion.

2011-03-16T22:07:00.011-05:00

This article will discuss a simple insertion sort algorithm in Java.
See ALL Java Postings | Insertion Sort By Language Java Scala Go Python Perl

Discussion of Insertion Sort
Insertion sort is one of the most natural ways of sorting a collection of comparable items. The reason it is one of the most natural ways is because it is the way most people will sort physical items. For example each year (about this time) I will sort all 12 of my previous years phone bills, gas bills, etc... The algorithm used to sort them is to place the first one in stack. Then the second one is compared to the first one to see if it goes in front of or behind the first one. The third one is then compared to each if the two sorted items to determine where it fits in. This procedure continues until all 12 bills are in the pile. Once all 12 bills are in the pile it is sorted. I happen to sort form oldest to newest, my spouse does it the other way newest to oldest.

Applying this concept to a collection of objects in a computer is fundamentally the same. The algorithm dictates that one will iterate over a collection of elements in an unsorted list 1 at a time, and place that item into it's correct location in a sorted list.

If the collection of objects to sort is n, insertion sort will take at most $O(n^2)$ operations to perform the sort, it will take on average $\frac{1}{2} O(n^2) = O(n^2)$, and in the best case senario will take $O(n)$ operations.

Questions:

1. What would be the initial characteristics of a list that took the worst case order $O(n^2)$ to sort?
2. What would be the initial characteristics of a list that took the best case order $O(n)$ to sort?

Java Solution:

/*------------------------------------------------------------------------------
   Copyright (c) 2011 ecocrypt.com

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 -----------------------------------------------------------------------------*/
package insertionsort;

import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;

public class InsertionSortAlgorithm<type extends Comparable> {
    Collection<type> unsortedCollection;

    public InsertionSortAlgorithm(){
        unsortedCollection = new ArrayList<type>();
    }

    public InsertionSortAlgorithm(Collection<type> sourceCollection){
        unsortedCollection = new ArrayList<type>(sourceCollection);
    }
    public void add(Type element){
        unsortedCollection.add(element);
    }
    public Collection<type> getUnsortedCollection(){
        return unsortedCollection;
    }

    public List<type> sortWithInsertionSort(){
        LinkedList<type> sortedList = new LinkedList<type>();
        for (Type nextObject : unsortedCollection) {
            sortedList = placeInSortedList(sortedList,nextObject);
        }
        return sortedList;
    }

    private LinkedList<type> placeInSortedList(LinkedList<type> sortedList, Type nextObject){
        int insertionIndex = 0;
        for (Type object : sortedList) {
            if(nextObject.compareTo(object)>0){
                break;
            }
            ++insertionIndex;
        }
        sortedList.add(insertionIndex, nextObject);
        return sortedList;
    }
}

Answers:
1. The best case senario would be order: $O(n)$
2. The worst case senario would be order: $O(n^{2})$

Scala - Hello World

2011-03-13T17:31:00.023-05:00

Scala's Hello World can be either similar to Java's, or simpler depending on how the problem is approached. This article will approach the problem from both the Java style as well as the much more pure functional style. Remember that Scala is a highly expressive functional language. The second form of the hello world program will show this feature much more clearly.

Step 1: Create a Scala source file

Scala does not have the same restrictions on source file naming that Java has. Therefore, you can give the Scala source file pretty much any name you like, so long as it ends in .scala. The fist form of Hello World looks as:

__________________________________________________________________________________

object HelloWorld {
    def main(args: Array[String]) {
      println("Hello in scala from ecocrypt.blogspot.com")
    }
  }

__________________________________________________________________________________

Step 2: Compile the Scala Source

At a command prompt, type the scala compiler command:

prompt %
prompt % scalac HelloWorld.scala
prompt %

prompt % scalac HelloWorld.scala

The result of this will be to produce an output file called HelloWorld.class, this class file is a byte code version of the HelloWorld.scala source file. This class file is identical to a Java class file, but has Scala class references embedded in it.

Step 3: Running HelloWorld

At the command prompt, type:

prompt %
prompt % scala HelloWorld
Hello in scala from ecocrypt.blogspot.com
prompt %

prompt % scala HelloWorld

Hello in scala from ecocrypt.blogspot.com

Congratulate yourself! You have successfully installed the Scala compiler and execution environment, created a simple scala source file compiled it to byte code, and run it inside of the Scala/Java Virtual Machine.

The exact same thing could be accomplished using a scala Application. The source code for a Scala application based solution would look as:

__________________________________________________________________________________

object HelloWorld2 extends Application {

println("Hello world in scala from ecocrypt.blogspot.com")

}

__________________________________________________________________________________

C++ - Hello World

2011-03-13T01:16:00.002-06:00

C++'s Hello World is similar to Go's (golang), but there are some differences. The similarity is that both C++ and Go create a file that is executed natively on the platform it is compiled to. Also both C++ and Go follow a procedure of compile then link. The main differences, for the Hello World program, are in the expressiveness and the syntax. Writing hello world in C++ requires the following steps:

Step 1: Create a C++ source file

The source file for Hello World thus looks like the following:

__________________________________________________________________________________

#include <iostream>

using namespace std;

int main(int argc, const char** argv){

cout<<"Hello World in C++ from ecocrypt.blogspot.com"<<endl;

return 0;

}

__________________________________________________________________________________

Save this to any file name you like, but typically, you will have to have a .cpp extension on the end of the file name. A good name to choose for this example would be helloworld.cpp.

Step 2: Compile the C++ Source

At a command prompt, type the c++ compiler-linker command:

prompt % c++ HelloWorld.cpp

This will typically do a 2 step process of compiling and linking. Therefore no intermediate object files will be created. The result of this will be to produce an output file called a.out, or a.exe.

Step 3: Running HelloWorld

At the command prompt, type:

prompt % a.out (or a.exe on windows)

Hello World in C++ from ecocrypt.blogspot.com

Congratulate yourself! You have successfully installed a C++ compiler, and created a simple hello world executable.

Perl - Hello World

2011-03-13T00:35:00.001-06:00

Writing hello world in perl is almost to simple to justify a post, however there are some caveats and for completeness of this group of posts, it will be included.

Step 1 Install Perl (5.x)

Once installed, make sure that you can access the perl executable. If perl is not in the path, you will need to add it.

Step 2 Create a Perl Source file

______________________Source File____________________________

#!/opt/perl

print ("Hello World in Perl from ecocrypt.blogspot.com")

______________________End Source____________________________

save the source to a file called helloworld.pl (or any other name of your choice)

Step 3 Tell Perl to execute the input file

prompt % perl helloworld.pl

Hello World in Perl from ecocrypt.blogspot.com

Congratulate yourself! You have successfully installed perl, create a perl source file, and executed it.

Java - Hello World

2011-03-13T00:16:00.008-06:00

Java's Hello World is simpler than Go's (golang), but not as simple as Python's. Also like python the output is quite portable from platform to platform. Writing hello world in Java requires the following steps:

Step 1: Create a Java source file
There are actually quite a few caveats to this step alone because Java as some requirements that make it more restrictive than any other language in this blog. In Java, there everything is an "Object" and thus extends from java.lang.Object. Therefore, you will have to create a full class definition even though we will not be instantiating any classes. The source file for Hello World thus looks like the following:
__________________________________________________________________________________

public class HelloWorld extends java.lang.Object {
    public static void main(String args[]){
        System.out.println("Hello World in Java from ecocrypt.blogspot.com");
    }
}

__________________________________________________________________________________

There is another caveat in Java the class HelloWord must be stored in a file called HelloWorld.java. Picking another name will cause a compiler error.

Step 2: Compile the Java Source
At a command prompt, type the java compiler command:
prompt % javac HelloWorld.java

The result of this will be to produce an output file called HelloWorld.class, this class file is a byte code version of the HelloWorld.java source file. Unlike golang, where the output of the linker can be directly executed, the java class file is not executable. However, a java executable program and load the HelloWorld.class file, and execute the instructions.

Step 3: Running HelloWorld
At the command prompt, type:
prompt % java HelloWorld
Hello World in Java from ecocrypt.blogspot.com

Congratulate yourself! You have successfully installed the JDK, created a simple java source file compiled it to byte code, and run it inside of the Java Virtual Machine.

Go Lang - Hello World

2011-03-11T19:53:00.002-06:00

Starting a new language the first example is always Hello World. Getting going with go-lang is only slightly different. As of this writing, the current state of 'go-lang' is that you have to build the compiler first, and then write compile and run Hello World. On UNIX/Linux you can do that pretty easily based on the instructions maintained on the golang.org website. On windows the GOMINGW seems to be maintaining good binary compatible version of go built with the mingw compiler collection on windows.

Step 1 Set your environment variables:

E.G. On my windows box I set:

set GOROOT=C:\golang\go
set GOOS=windows
set GOARCH=386

(look in $GOROOT/pkg for applicable architecture and OS Options)

Step 2 Create a source file in the go language (a go source file):
Use a text editor or write a golang source file:
Sample Hello World GO Language source file:
________________________SOURCE FILE________________________________________

package main

import fmt "fmt" // Package implementing formatted I/O.

func main() {
fmt.Printf("Hello, world; from go to ecocrypt.blogspot.com \n")
}

________________________END SOURCE_________________________________________

Save this file to helloworld.go or any filename of your choice.

Step 3 Compile
prompt % 8g helloworld.go

Step 4 Link
prompt % 8l helloworld.go

Step 5 Run the newly created executable:
prompt % 8.out
Hello, world; from go to ecocrypt.blogspot.com

Congratulate Yourself! You have created and run Hello World in Go.
You should now have a Go compiler successfully installed on your computer.

SOME COMMON ERRORS:
Using the wrong executable to compile go source:
prompt % 8c.exe helloworld.go

helloworld.go:1 not a function
helloworld.go:1 syntax error, last name: main

This Error is caused because you are trying to compile a go source file with a c compiler. 8c is a c compiler embedded in the go distribution package.

Using the wrong architecture or os settings:

prompt % 8g.exe helloworld.go

helloworld.go:3: can't find import: fmt

Make sure you have set the go environment variables correctly:
Determining the GOOS, and GOARCH can be tricky, you will have to look in:
$GOROOT/pkg/
and there will be a directory of format $GOOS_$ARCH

E.G. On my windows box I set:

set GOROOT=C:\golang\go
set GOOS=windows
set GOARCH=386

Python - Hello World

2011-03-09T21:58:00.004-06:00

Writing hello world in python is almost to simple to justify a post, however there are some caveats and for completeness of this group of posts, it will be included.

Step 1 Install Python 3.2
Once installed, make sure that you can access the python executable. If python is not in the path, you will need to add it.

Step 2 Create a Python Source file
______________________Source File____________________________
#!/opt/python
print ("Hello World in Python from ecocrypt.blogspot.com")
______________________End Source____________________________
save the source to a file called helloworld.py (or any other name of your choice)

Step 3 Tell the Python Interrupter to execute the instructions in the file
prompt % python helloworld.py
Hello World in Python from ecocrypt.blogspot.com

This entire exercise could have been done from within the python interrupter. To start the interpretor simply type 'python' at the command prompt this will give you a python interpretor prompt:

>>>
>>>print ("hello world in python from ecocyrpt.blogspot.com")
hello world in python from ecocyrpt.blogspot.com
>>>
type quit() to leave the interpretor

SOME COMMON ERRORS:
Using the wrong Python Syntax for version 3.2.

>>> print "Hello World"

  File "<stdin>", line 1
   print "Hello World"
   ^
SyntaxError: invalid syntax

>>>

There were some syntax changes between python 2.7 and 3.2.
This fails because the print method is not enclosed in braces().
Try >>> print ("Hello World")