February update

This is just a quick update on the progress of the OctoMY™ project.

The work to implement the plan set forth at the anniversary is well underway!

Today I pushed maybe one of the most substantial commits made so far in the entire history of the project. Nothing has changed in the main branch of the code, but if you look under integration/v2 you will find a complete copy of the root.

Why did I do this instead of using a git branch? Because it allows me to directly compare the two and copy between them without having to check out a separate repository.

In the new "branch" the following has so far been done:

• Number of compiler warnings has been greatly reduced. The entire build now generates just 76 warnings! The work to remove them will continue.
• Libraries have been renamed, merged, split, and removed so that the whole namespace is much cleaner.
• librest has been renamed to more appropriate libcombined.
• Widgets and their respective .ui files have now been distributed out to the libraries where they belong.
• Resource files have also been distributed out to the libraries where they belong. Some more tweaking of the build is needed for resources to be properly linked though.
• Many folders including those of libraries have received their own README.md file that describe them better. There is still room for more.
• Many files have had more information put into comments, especially for the build system!
• Build system now looks for .ui and resource files like it does for sources.
• Build system was modularized a little and cleaned up a bit.
• A lot of sources have been brought up to spec with regard to coding style!
• The build time has been cut in half (!!) mainly because of splitting Utility header into parts with the most used parts (OC_METHODGATE, OC_NEW and OC_CONTYPE) being put alone into dedicated headers (but many other small changes may have contributed).
• The initial startup code of Node & al. has been massaged to work much better and tested with a Mock Node. The startup of Node is now well documented.
• Lots of  objects are now passed around as QSharedPointers instead of raw pointers or raw references. Countless classese now have empty contstructor parameter lists and instead have a separate .configure() method to do the actual initializations which avoided the bad practice of running code from constructor initialization list (althought RIIA suffered a little, I think this was a worthwhile update).
• A completely empty Agent and matching AgentWindow class has been created ready for constructing a new Agent from the ground up.

I was honestly worried that the goal I set for this project was too big. A huge thanks must go to Mrs. Y for her motivational support!

Now that we are here, the "real" work starts! I am really excited!

Update will follow as soon as there is anything to report...

Happy Anniversary 2019

The 7th of January 2019 marks the three year anniversary of the OctoMY™ project. As promised, a roadmap for the project will follow. Great things are ahead!

A new version has been created in-tree simply called "v2". It started as an empty folder, and will be gradually filled with all the parts of the project code that works.

Each part will be scrutinized thoroughly and polished up to meet a high standard. The following rules apply:

• No compiler warnings or errors allowed.
• Some libraries renamed to better more descriptive names.
• Some libraries merged.
• Some libraries split up, especially libcore and libutil.
• Some libraries or parts will be removed outright.
• Widgets and ui files are distributed among the libraries they belong to.
• Resource files are distributed among the libraries they belong to.
• All libraries receive README.md to describe them better.
• Formatting of sources modified to follow the standard.
• Translation unit optimizations to reduce buildtime.

Once all the dependencies have been cleaned up the next phase begins;

1. Empty dummy classes called NodeV2 and AgentV2 are created that will build and run but not actually work.
2. The messy interfaces of node and agent are cleaned up and homogenized.
3. Each feature is re-integrated one by one into the V2 classes ensuring that they work, creating unit and integration tests as the project progresses.

This will eventually leading to the completion of the MVP, our first minimum viable product.

Once this MVP works it will be tweaked, optimized and polished in stages until we have a realease candidate for testing.

This roadmap has the advantage that the progress can be measured and followed closely. Instead of crossing fingers and hoping, we can actually see what remains on a burn down sheet.

We are looking forward to work further on this, the work already started. Happy anniversary!

Merry christmas & happy new year 2019!

The tumbleweed rolling over this blog and the the OctoMY website might not give it away, but I assure you, under the surface there really is a lot going on.



So now that is juletide and we are at brink of the new year, it felt only right to reveal a few highlights that hopefully will be followed up with some good news early to mid 2019!

So to start, we now have 2 workshops, not just one. Yes that is right! The garage has continued to mature as a mechanical workshop, and we now also have a brand spanking new electronics workshop in the basement.






We have also hoarded a lot of new tools and parts. Mostly it is boring stuff like a resistor collection, heat shrink tubes and zip-ties but there are also a few cool things, like a stereo microscope with camera, hot air station and a karaoke machine (!!!).



And there has gone a lot of preparation into starting the YouTube channel. Cameras are in place, storage server for content has been set up, dedicated editing laptop is in place to name a few.

On the software side, a lot of important work has been put in place over this year. We have really struggled with some hard bugs, and killed many of them. A complete list of the remaining work before we have a first release will be revealed on the anniversary summary of the project at 7th of January 2019, but here is a short summary:

• The async store has finally been completed FINALLY!
• The first successful build on the windows platform was done (thanks to the excellent folk over at HolbergEEG for giving me a chance to get back into windows dev for money)!
• Repairing the sub-systems that fell during the async store restoration process.
• Built a tool to replace the official website, and to migrate content from it.
• Lots of tiny stuff
• refactoring
• cleaning up
• removing small bugs
• removing inconsistencies
• removing compiler warnings
• adding useful comments
• etc.

And finally, the most important of all; we have made the biggest decision for the project a few days ago. We realized that async store was just an example of a whole breed of problems that will occur in the near future. For every grand bug or architectural problem we fix, there is just another one lined up to take it's place. It has become impossible to plan for success, we are in a reactive stance.



To get away from this, we have made a very tough decision. It is tough because it means a lot of hard work, and a lot of time that we really did not want to take on, as we already have our hands full with other meaningful stuff. But in an effort to take back control over the project we have decided to pull "a Netscape". That is, to stop development on the current version as it is, and instead build a version 2 that will copy only the working parts from the existing project, and gluing things together in a better, more documented way.

In the business world this decision is often frowned upon as a bad move. The risk is that the effort will take much longer than first anticipated. One often underestimates the good aspects of the version you already have. After all it is the culmination of ALL the work you have put into the project so far!

On the other hand, we are not a business, and we know our code base very well. It is reasonably modular and structured. Few things really inter-tangle all that much except the parts that we are trying to fix, and those are the parts we want to work on anyway. By re-establishing the code base part by part will give us an opportunity to separate concerns even further, to remove old legacy stuff, to re-organize, document and simplify everything thoroughly.

Most importantly, it will allow us to separate what definitely works from what remains to be made/fixed. There will be no more guesswork as to how much remains before the project can be crowned with its first release. And just knowing this alone we felt was worth the effort.

Work is already underway. We have decided to do this in-tree. That way the history of the parts we use will be somewhat maintained. We also don't need to fiddle with extra repositories. In other words, everything will remain as it used to be for the most part, but you can now open a new OctoMY.pro file from integration/v2/OctoMY.pro if you would like to work on this new version.

On behalf of OctoMY, I would very much like to wish you a merry christmas and a hapåpy new year 2019!

Website migration

In an earlier post we mentioned our wish to transition away from github after it being acquired by Microsoft.

Now, we announce that we will be migrating our website away from google sites. The reason is that google has rolled out a replacement for the classic sites, and are heavily promoting migration which indicates that the classic sites may be phased out. Here is an official post from google which is vague to the point of laughable: (post on deprecation of google sites classic)

To save our future selves from tedious meta work like this, we hope this will be the very last time our website needs to be migrated. The way we intend to make sure it is indeed the last time, is outlined in the migration plan posted here.

Hats of to Boston Dynamics

Tis what we like to see!.