An End

Hello there,

the last months have been strenuous, but soon the study is done. That means that TLT is over too. We finished our Studienarbeit and completed the task. We implemented a prototyp in Unity and wrote a scientific work about it. You can find the document and other important things in our repositories. Even if this blog isn't extensive it was nice to work with this topic. Thank you.

GitHub-Studienarbeit

Thank you and Goodbye,
TLT-Team

What happened the last three months?

Hey guys,

there was little information about TLT in the last three months. The reason for this is simple. There has been no progress in developement, so there was nothing intreresting to write about. Franziska and I had to concentrate on our research paper whose deadline is on 15th January, 2018. We have been working on it for the last three months and are happy to finally be able to program again. Hopefully there will be more postings about this now.

You can read our work here.

Thank you for your patience,
TheLearningTriangle-Team

Say hello to the new team member, Franziska Neumann!

Hey guys,

long time no see!
The sixth semester started and some things have changed because of Studienarbeiten. First of all, there is a new person in the LearningTriangle-Team. It's Franziska Neumann, a student at the same year as me! Visit the "About the project" site (which is coming soon) for more information about her. She is looking forward to further developing the project!

Have a nice day,
TheLearningTriangle-Team

Take a look at the new UI

Hey guys,

after some problems with GitHub today, we can finally show some achivements! We redesigned some elements of our UI, which was good enough in the past but will hopefully be better now.
We used a freeware tool to design some textures for our fields. Except the lacking skill of Pixelart, the result is an improvement. You can switch texture-styles given that you have enough different images. This should bring some variety inside our program.
Enough talk, here are some pictures:

The old UI... modest, but sufficent.

Welcome our new UI (feat. some textures)!

Alternate look (RPG-Style)

 It is a question of taste, but in our opinion things became better. Have a nice day!
TheLearningTriangle-Team

Status Update!

Hello Guys,

the course "Software Engineering", the main reason why this project exists, ended a few weeks ago. But that doesn't mean the end of "TheLearningTriangle". We will continue this project and the researches. Also from now on, the blog entries aren't any homeworks for a course. We will publish them when there is something useful/interesting to know when following our project. Also there are some other information:

• "We" isn't Steven and Marco anymore. Steven has left this project to concentrate on other important things. We will release further information about the team soon.
• As you know, our first idea was to use Tensorflow and Python. During the project, our specifications changed in another direction. In the future, we will evaluate the existing project and maybe there will be some restructuring afterwards. We want to concentrate on things like new rules and new game mechanics, but the most important Thing will be the AI. We want to implement different algorithms and see how they work on our project. These researches will also be published in form of an "Studienarbeit" on the DHBW.
• We designed another logo, have a look:

Thank you for your time and understanding!

Marco Müller

Final Term - Written Handin: One entry to rule them all

Hey guys,

the fourth semester is finished, the project LearningTriangle comes to an end. For our written handin we have to give a link to a blog entry for all topics. We decided to create this entry for a better overview.

---------------------------------------------------------------------

Use Cases 

For our Use Cases we created Use Case Specification documents. We listed them here. The GitHub links were created on 01.07.2017 and contains the files as PDF. You can leave comments in the drive-documents.

( Drive | GitHub ) Create World
( Drive | GitHub ) Calculate Score
( Drive | GitHub ) Update View
( Drive | GitHub ) Field Rules
( Drive | GitHub ) Building Up Neuronal Network
( Drive | GitHub ) Collecting Data through Triangles
( Drive | GitHub ) Control Triangle
( Drive | GitHub ) Set Triangle Rules

SRS

You can find our SRS in THIS blog entry and in our GitHub (HERE).

Test Cases, Test Log and Functional Test

Informations about our .feature files can be found in THIS blog entry. They are also in every Use Case document from the first semester. We also listed them here:

- TLT_UC_CALCULATE_SCORE.feature

- TLT_UC_CREATE_WORLD.feature

- TLT_UC_UPDATE_VIEW.feature

- TLT_UC_FIELD_RULES.feature

Information about testing in the LearningTrianle can be found HERE.

Test Plan

You can find our Test Plan on THIS blog entry.

Automated Testing functional

 isn't there, because we didn't spend time until now to automate our tests. They are developed during the process of programming, we want to realise it in the future.

RUP Gantt chart

Visit THIS blog entry for informations about our role defining process with RUP. The Gantt chart should be HERE.

Jira / Burndown

Visit THIS blog entry for our Jira/Burndown.

FP calulation

The FP calulation (or the explanation why we didn't calculate them) can be found HERE.

Demo

To deploy our project and run it follow the instructions in THIS blog entry.

Code

You can visit our GitHub repository for our code.

Architecture SAD document

You can find our SAD in THIS blog entry and in our Github (HERE).

Metrics

For Metrics, visit THIS blog entry.

Risk Management

Our risk management can be found in THIS blog entry. You can ignore the Use Cases, they are the same as above.

Patterns

Informations about patterns can be found in THIS blog entry and (like also mentioned on the entry) in our SAD.

Presentation

Presentation slides can be found HERE.

Installing our project on your own PC + Automated Deployment

Hello guys,
we want to explain how to deploy our project and to start it.

We believe that our project is only interesting for people with some interests in AI. Normally these persons are developers and know how to use GitHub and an IDE. Thats the reason why we decided to design our guide like this:

1) Run your IDE
2) Fork our project from GitHub
3a) Run "Application.java" for view
3b) Run "Train.java" for training. You can choose how many cores you want to use by adding more or less createRunner()-methods.

This process will be redesigned when the project changes. But at first there isn't a automated deployment planned, because it doesn't make sense in our case.

Have a nice day,
TheLearningTriangle-Team

PS: visit our GitHub for the latest deployment guide!

MVC will get a friend (Patterns)

Hello guys,

we want to say something about patterns. As you know from previous posts, we folloewd the MVC-Pattern to structure our architecture. Now we added the factory pattern to build some of our objects.
We explain it in our SAD in the section Architectural Gaols and Constraints.

Have a nice day,
TheLearningTriangle-Team

Metrics in our project

Hey guys,

until now we were not able to count how many lines of code we have or how many methods are in our project. Ohter metrics like McCabe or Distance from the Main Sequence couldn't be calculated either.
We decided to use Metrics 1.3.6, an eclipse plugin, to show these numbers in our IDE. Have a look:

Metrics of Learningtriangle (last update 21.06.17)

As you can see, the Nested Block Depth is red, which means "not good".  After every method, the code is indented one more time, the number how often this happens is the Nested Block Depth. You shouldn't have a value this high, if you follow the Object Calisthenics the level of indentation is maximized to 1.
We tolerate this value because it happens in the learning algorithm, where beginners can't fix this value that easy. Also its only in this one method, so the impact isn't dangerous.
The other values aren't perfect, but ok.
 For more information, have a look in our SAD.

Have a nice day,
Marco from TheLearningTriangle-Team

Software Architecture Document

Hello guys!

Today we will present you our "Software Architecture Document" where we want to show you, how our project is designed. We describe what design patterns out project uses and also how our class diagram looks like today.

If you follow this link, you can easily have a look at our "Software Architecture Document".

Greethings!
TheLearningTriangle-Team

Function Points and the calculation of them

Hello guys!

Considering our project and its research scope we do not have much user interaction with our program. This is why we can't provide a function point calculation. We spoke with Mrs. Berkling about this issue and she accepted that we can't provide it. So we did not.

Our project just consist on one view which just appear if we want so. We also have no user interaction with the user, since we just want to see how our triangle is doing in our artificial world.
Therefore the score it reaches is enough for us.

Greethings,
TheLearningTriangle-Team

Refactoring (not related to LearningTriangle)

Hello guys,

this week each of us used some time to look at refactoring methods. We used the book "Refactoring" from Martin Fowler and Kent Beck. We created a new repository to track our progress. Take a look:

Marco
Steven (didn't created one)

Have a nice day,
TheLearningTriangle-Team

PS: even without the "compulsion" of the Software Engineering course, I can recommend the book. The content is useful.

Unit Testing

Hey guys,

today we want to show you our thoughts on testing.
We mentioned at the beginning of this project that we want to develop test-driven. This means testing before coding. Further information about this topic and its influence can be found in our test-document.

In this post you can also find some test code which was written for our triangles and their functions. Each test method was written before there was an implementation of the code. We have to admit that it was hard to follow our first idea of TDD at some points. But only if you can resist the pain its possible to become better and you will feel how your code becomes "better" in many cases without extraordinary work.

RUP Test Plan

Some Test code: TriangleTestCode | FieldTestCode

There are some example of a test showing the result:

working test

failed test

Thank you for visiting our blog,
TheLearningTriangle-Team