With that idea in mind, I decided to try my hand at creating my own intelligent assistant: Synthia, the Synthetic Intelligent Assistant for your home.

Synthia is an application that can integrate the best available AI services and be run on cheap and customizable hardware. Using the $35 Raspberry Pi 3, you can setup an agent in your home that can see, hear, and respond to your commands with a wakeword.

What Synthia will do that others cannot is use a camera pointed at your door to let you know when and who enters your home—and alert you when unrecognized persons are detected. Not only that, but Synthia will greet you and respond to your commands when you get home; from playing music to turning on smart-home lights. Synthia is going to be the digital doorman for your home.

Most importantly, Synthia is and will always remain free. Synthia is open source so that the maker community can extend and contribute to the project. Synthia was kickstarted at a Hackathon with contributors Geoffrey Khorn & Sarah Carroll.

Synthia on GitHub

To get started, download Play with Activator here: https://www.playframework.com/download

Next, install Play by adding Activator to your PATH by following the instructions here: https://www.playframework.com/documentation/2.3.x/Installingdownload

Play allows you to code with either Java or Scala. For the purposes of this example, use Java by adding "play-java" to the activator command. Go to the parent directory of where you want to create your project directory and run the following commands:

activator new event-subscriber play-java
cd event-subscriber
activator run

After Activator and Play finish downloading dependencies and starting, navigate your browser to http://localhost:9000/. The following screen should appear:

Your project's directory structure should look something like this:

build.sbt
app
  └ controllers
  └ models
  └ views
conf
  └ application.conf
  └ routes
logs
  └ application.log
project
  └ build.properties
  └ plugins.sbt
public
  └ images
  └ javascripts
  └ stylesheets
test
  └ ApplicationTest.java
  └ IntegrationTest.java

Navigate to app/controllers and make a new controller named Events.java:

For this example, we only need one instance of a Publisher actor. However, we need a new instance of Subscriber for each client connected to the server. Navigate to app/models and define the Publisher and Subscriber actor models as follows:

In Publisher and Subscriber we are using DistributedPubSubExtension to allow for a clustered publish-subscribe system. To setup our cluster, add the following to conf/application.conf:

More cluster nodes can be added depending on the scale of your application. We do need to add a few dependencies to our build.sbt in order to compile our project:

Next, let's add some routes to conf/routes so we can access the Events controller from the web browser:

We will need some simple views to present our event data through WebSockets. Add jQuery to app/views/main.scala.html:

Create a new JavaScript file in app/views/event.scala.js and modify app/views/index.scala.html to resemble the following:

Restart the server by running "activator run" again in the parent project directory. You can also add another form view to test out sending events to the publisher and see the following:

All of the source code for this example is available here: https://github.com/TomAlanCarroll/event-subscriber

For now, let's start out by defining a simple test case to follow test driven development. Since the Fibonacci sequence is infinite, we'll use Java's BigInteger class to handle numbers outside of the range of ints and longs.

@Test
    public void testIsFibonacciWithBigIntegers() {
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < TestData.fibonacciNumbers.length; i++) {
            assertTrue(Fibonacci.iterativeIsFibonacci(TestData.fibonacciNumbers[i]));
        }

        for (int i = 0; i < TestData.nonFibonacciLargeNumbers.length; i++) {
            assertFalse(Fibonacci.iterativeIsFibonacci(TestData.nonFibonacciLargeNumbers[i]));
        }
        long endTime = System.currentTimeMillis();
        System.out.println("Completed iterative Fibonacci test in " + (endTime - startTime) + "ms");
    }

public class TestData {
    public static final BigInteger[] fibonacciNumbers = {
            new BigInteger("0"),
            new BigInteger("1"),
            new BigInteger("1"),
            new BigInteger("2"),
            new BigInteger("3"),
            ...
    public static final BigInteger[] nonFibonacciLargeNumbers = {
            new BigInteger("9539593446744073709551615"),
            new BigInteger("7492050343423470955161623"),
            new BigInteger("7382950684327734869302126"),
            new BigInteger("2382132136549430123910054"),
            ...

So now let's try the most obvious solution: iterate over the fibonacci sequence until we either exceed the number being tested or match it:

public static boolean isFibonacci(BigInteger number) {
        BigInteger Fprevious = BigInteger.ZERO, Fn = BigInteger.ONE;

        if (number.compareTo(BigInteger.ZERO) < 0) { return false; }
        if (number.equals(Fprevious) || number.equals(Fn)) { return true; }

        while (Fn.compareTo(number) < 0) {
            BigInteger temp = Fn;
            Fn = Fn.add(Fprevious);
            Fprevious = temp;

            if (Fn.compareTo(number) == 0) {
                return true;
            }
        }
        return false;
    }

This approach is far from ideal because every previous Fibonacci number must be iterated through. Another approach, proved by Phillip James, is to verify at least one of these calculations is a perfect square:
or
Let's try this out using Java's BigInteger class:

public static boolean binetIsFibonacci(BigInteger number) {
        if (number.compareTo(BigInteger.ZERO) < 0) { return false; }

        BigInteger product = number.pow(2), four = new BigInteger("4");
        product = product.multiply(new BigInteger("5"));

        if (BigIntegerMath.isSquare(product.add(four)) ||
            BigIntegerMath.isSquare(product.subtract(four))) { return true; }
        return false;
    }

BigIntegerMath.isSquare determines whether a given number is a perfect square using Newton's method. The source can be found here.

Unfortunately, the need to calculate the square root slows down the Fibonacci check so severely that the Binet approach takes 4 to 5 times longer than the above iterative approach as seen here:

Completed Binet Fibonacci test in     689ms
Completed iterative Fibonacci test in 150ms

All source code is available here: https://github.com/TomAlanCarroll/coding-practice/tree/master/src/main/java