RUP: Defining roles

Hey Guys,

Today we want to talk about our team, Steven Kovacs and Marco Müller.
In a project it is important to be clear about everyones exercises and tasks next to coding.
Also in our project we want to define roles. We'll use IBM's RUP, a well-known system for business to give different roles to different members. For further information you can look at this site.

In a team with only two people it is really difficult to divorce between each role. But we tried to be as clear as possible, but some roles will be important for both of us. In the following picture you can see our team members and their roles in this project:

Next to our roles, we want to be clear about our technology. We already mentionted that we will use Tensorflow, an Open Source Software developed by researchers from the Google Brain Team. Our structure consists of two main parts (there will be much more parts, but for the explanation of our technology these both are the important ones):

The first part is our AI on a server, programmed in Python with Tensorflow. The other part is our "game", programmed in Java. This includes the game mechanics, the models and the graphical view. Also we want to use the following things:

• We will use the MVC pattern for our Java structure, not only because it keeps our code more organized, but also because structured code is important when using a server-structure.
•  Next to this, clean code is a realy important thing, so we will try to keep our code as simple and clean as possible. This means that we will use clean code patterns.
• One last thing to mention is that we want to develop our porgram test-driven. That means, that every single line of code we will write will be tested before we build our project. To guarantee the functionality of this we use JUnit in combination with Mockito, a Mocking-Framework.

It is a good question to ask why we try to follow these rules. Whoever programmed with clean code patterns and TDD (Test-Driven-Development) knows that it is sometimes really hard to resist the simple way of coding. But this simple way isn't in our opinion a good way. Structure and Overview lack when a project becomes to big and you haven't obey some standards.
Wer know that sometimes it will become really hard, but our goal is to to write good, clean code and resist every single temptation. That's the reason why we program our project this way!

Greets,
TheLearningTriangle-Team

First OpenGL graphics tested

Hello guys!

We just uploaded a test for our graphics library. We are going to use OpenGL (JOGL) to draw our little cute triangles. :)

You can download this test from our git-repository.

It's ugly but it works for now.

You can also move the triangle using wasd. It is moving on all pc's at the same speed, because we are including the time between two draw mechanisims.

We've had some fun moving this thing around. :)

- TheLearningTriangle Team

Setting up Tensorflow on a server

Hello everyone!

We now have setted up a linux server acting like a cloud for our tensorflow application providing same data and neuronal network for all developers!
We followed the instructions of Tensorflow Installation.
We also tested the new environment with the installation test and from the introduction page:

import tensorflow as tf
import numpy as np

# Create 100 phony x, y data points in NumPy, y = x * 0.1 + 0.3
x_data = np.random.rand(100).astype(np.float32)
y_data = x_data * 0.1 + 0.3

# Try to find values for W and b that compute y_data = W * x_data + b
# (We know that W should be 0.1 and b 0.3, but TensorFlow will
# figure that out for us.)
W = tf.Variable(tf.random_uniform([1], -1.0, 1.0))
b = tf.Variable(tf.zeros([1]))
y = W * x_data + b

# Minimize the mean squared errors.
loss = tf.reduce_mean(tf.square(y - y_data))
optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(loss)

# Before starting, initialize the variables.  We will 'run' this first.
init = tf.initialize_all_variables()

# Launch the graph.
sess = tf.Session()
sess.run(init)

# Fit the line.
for step in range(201):
    sess.run(train)
    if step % 20 == 0:
        print(step, sess.run(W), sess.run(b))

# Learns best fit is W: [0.1], b: [0.3]

 by Tensorflow Introduction

Wow! We can learn mathematical rules and patterns!

Start of our project "thelearningtriangle"

Hello guys!

We are now initializing the project "thelearningtriangle".

The main idea of "The Learning Triangle" is a game which consists of two major parts: A world and some creatures. These creatures want to survive inside the world, but in this project there isn't a player controlling the creatures. An algorithm must deal with this exercise.

The world is created randomly with walls, eatable fruits, energy/deadly fields and poisones fruits. The following image shows a first design and isn't final.

first sketch of a random world

Creatures are symbolized as triangles. Each of them can move inside the world and explore the field. They need energy to keep themselfes alive so they have to find and eat eatable fruits. Creatures can replicate themselfes with a fixed cost plus 50% of the remaining health. They also have a running-speed and field of view. The last few visited places can be saved in a triangle.

Triangles Goal:
Walking distance as far as possible.

We want to program this project in python and java with Google's API for maschine learning "Tensorflow".

You can find our project on this GitHub page.