Release 0.9.0-β

Big release with the smart bubble, and much more.
Required kivy version is bumped to kivy 1.10 for recycler view.

Features
* Added a context menu (aka Smart Bubble) that suggest suitable blocks.
* Smart Bubble has a search bar.
* Execute button now it's a play button.
* Added right click hint when no block is present.
* Added STR type (represents string/results).
* Blocks can now be selected and removed pressing delete.
* Added info about what is going to happen when dragging.

Bug Fixes
* Print block could be spawned more than once through Smart Bubble.
* Right click when there is a Smart Bubble present it reset position.
* Focus on Smart Bubble search box now remains after creation.
* Removed coloredlogs dependency.

Refactoring
* Notification is now used static instead of as a field of blackboard.
* Pins now have their own sub-package.
* Blocks now don't need as much boilerplate as before.

Docs
* Polished academic objectives.
* Polished postmortem.

Author: AlvarBer

README.md

@@ -12,6 +12,13 @@ and type safety is enforced when the connection is being made.
 
 ![Type safety](docs/images/type_safety.gif)
 
+A smart bubble helps suggesting suitable context-sensitive blocks when making
+a connection, showing only the blocks which are type safe.
+There is also a search box that can be used for finding a particular block.
+
+![Smart bubble](docs/images/smubble.gif)
+
+
 How to install?
 ---------------
 If you have pip (Python 3.5+) you can simply type

docs/images/china.png

@@ -112,6 +112,7 @@ overcome the difficulties of learning the algorithms themselves.
 
 Objectives
 ----------
+<!--
 Research:
 
 :   On terms of research this project touches on a multitude of topics, from
@@ -127,44 +128,49 @@ Requirements:
     A good risk analysis can also prevent failures in a multitude of areas
     such as time management or technical debt.
 
-Design:
-
-:   The system has to be designed in accordance to those requirements, both
-    in terms of making it easy to progress through the milestones as well as
-    producing a usable software at each stage.
-
-Implementation:
-
-:   There are some **non-functional requirements**, such as the project running
-    on the desktop platform, being able to pack it into a executable (to make
-    evaluation easier for participants), have a framerate good enough for
-    pleasant use (minimum 30 FPS), or support multithreading (as to not block
-    the main/UI thread from running when executing the backend),
-
 Testing:
 
 :   The software needs to be testable, as to allow for the automation of
     testing on the source repository, caching bugs faster in the process.
+-->
+
+Feasibility:
+:   The project has to explore the space of possible solutions on visual
+    machine learning approaches, trying different estrategies for both the
+    front and backend of the application (Flow based programming, Dataflow
+    programming, etc).
+
+Design and Usability:
+:   The system has to be designed in accordance to requirements, both
+    in terms of making it easy to progress through the milestones, as well as
+    producing usable software at each stage.
+    In all cases it must balance complexity against expresivity, trying to
+    provide the user with a powerful tool while avoiding complex and
+    unusable interface.
 
 Evaluation:
-
 :   The software will be evaluated by participants that belong to the intended
     audience of the system, a form must be prepared detailing the task they
     will have to perform, as well as how their data will be treated.
 
-Learning:
-
+Learning Tool:
 :   The software will help both with the programming barrier, easing the
     learning curve of Machine Learning as to allow the learner to focus on the
     connections, intuitions and mathematical basis of the algorithms and not on
     the implementation details and the quirks of the language.
 
-Faster exploratory work:
-
+Faster Exploratory Work:
 :    By providing an easy to use, drag and drop interface the user can try a
      plethora of different estimators and adjusting the hyper-parameters as
      they see fit faster, and without writing a single line of code.
 
+Implementation:
+:   There are some **non-functional requirements**, such as the project running
+    on the desktop platform, being able to pack it into a executable (to make
+    evaluation easier for participants), have a framerate good enough for
+    pleasant use (minimum 30 FPS), or support multithreading (as to not block
+    the main/UI thread from running when executing the backend),
+
 
 What the project is not
 -----------------------

docs/images/final_aspect.png

@@ -1,71 +1,112 @@
 Postmortem
 ==========
 
-After the evaluation it is time to make a retrospective, and look what has
-been achieved and what has not.
-
-On the introduction several objectives were mentioned, let's revisit those.
-
-* Research. Background research was conducted on fields covered by the
-system. It was particularly interesting learning about the dataflow paradigm,
-because it is a niche I was not familiar with.
-It was also great looking at the available commercial solutions, they prove
-that there is a lot of enterprise interests on this kind of systems.
-
-* Requirements. The bi-weekly iterations worked reasonably well, there was not
-anything that got stuck or delayed more than one additional iteration.
-It also proved useful for having a usable system from even the first iteration.
-
-* Design. The final implementation followed the initial sketches pretty
-closely, proving the initial design had solid fundamentals, the good evaluation
-score, and the remarks given by the users demonstrates that while there are
-plenty of improvements that can be done it remains a good interface to use.
-
-* Implementation. At the end of the project the non-functional requirements
-have been met, delivering a windows single executable file that participants
-used for the evaluation, while keeping a good performance, handling many
-blocks without a hitch, and keeping the frame rate steady while modifying
-connections and running the execution of the pipeline simultaneously.
-
-* Testing. Probably the weakest part of the project because all the backend
-is based around visual elements unit testing proved pretty useless, and this
-part comprised the biggest part of the code.
-
-* Evaluation. Despite having a low number of participants the evaluation
-resulted in a mostly unanimous good reviews of the software, as well as
-providing very useful feedback for future improvements.
-
-* Learning. Because most of the milestones were achieved the final system has
-proved to be useful enough for its use as a learning tool, it was even
-remarked by two participants how easy it was to use, and how easy it was to do
-complex actions (such as hyper-parameter tuning) compared to other
-frameworks/libraries.
-
-* Faster exploratory work. I personally used the software for performing
-ml analysis, finding it worked pretty well for early exploratory work, when
-limited by the lack of a block it was pretty easy and fast adding a block
-that solved the problem (in around ~20 lines of code).
-During this use I realized another possible improvement, caching operations,
-with this the results of pipelines are not recalculated unless something
-changes upstream, this provides the closest thing to a visual REPL[^REPL].
-
-All the major milestones were reached except the compilation feature, this is
-because deciding the order in which blocks get translated means settling
-the current evaluation strategy, while leaving undecided means that some
-interesting such as optimistic evaluation can be implemented on the feature,
-for more on this check the type chapters, two languages section.
-
-In conclusion Persimmon has achieved most of the settled objectives, proving
+After the evaluation it is time to make a retrospective, look what Persimmon
+has achieved.
+
+
+Objectives Review
+-----------------
+<!--
+Research:
+:   Background research was conducted on fields covered by the
+    system. It was particularly interesting learning about the dataflow paradigm,
+    because it is a niche I was not familiar with.
+    It was also great looking at the available commercial solutions, they prove
+    that there is a lot of enterprise interests on this kind of systems.
+
+Requirements:
+:   The bi-weekly iterations worked reasonably well, there was not
+    anything that got stuck or delayed more than one additional iteration.
+    It also proved useful for having a usable system from even the first iteration.
+
+Testing:
+:   Probably the weakest part of the project because all the backend
+    is based around visual elements unit testing proved pretty useless, and this
+    part comprised the biggest part of the code.
+-->
+
+Feasibility:
+:   Using evaluation it can be concluded that it is possible to create a
+    machine learning visual interface that is as flexible as a language,
+    including a type system and errors in compilation time, and yet remains
+    simple to use, even for newcomers.
+
+Design and Usability:
+:   The final implementation closely followed the initial sketches, proving the
+    initial design had solid fundamentals.
+    The good evaluation scores, and final remarks given by participants
+    demonstrates that the interface has accomplished its objectives of
+    producing a powerful yet simple to use interface.
+    Features like the smart bubble that use instrospection to suggest suitable
+    blocks to connect leverage the type system to help the user create the
+    pipelines faster and easier.
+
+Evaluation:
+:   Despite having a low number of participants the evaluation
+    resulted in a mostly unanimous good reviews of the software, as well as
+    providing very useful feedback for future improvements.
+
+Learning Tool:
+:   Because most of the milestones were achieved the final system has
+    proved to be useful enough for its use as a learning tool, it was even
+    remarked by two participants how easy it was to use, and how easy it was to do
+    complex actions (such as hyper-parameter tuning) compared to other
+    frameworks/libraries.
+
+Faster Exploratory Work:
+:   I personally used the software for performing
+    ml analysis, finding it worked pretty well for early exploratory work, when
+    limited by the lack of a block it was pretty easy and fast adding a block
+    that solved the problem (in around ~20 lines of code).
+    During this use I realized another possible improvement, caching operations,
+    with this the results of pipelines are not recalculated unless something
+    changes upstream, this provides the closest thing to a visual REPL[^REPL].
+
+Implementation:
+:   At the end of the project the non-functional requirements have been met,
+    delivering a windows single executable file that participants used for the
+    evaluation, while keeping a good performance, handling many blocks without
+    a hitch, and keeping the frame rate steady while modifying connections and
+    running the execution of the pipeline simultaneously.
+
+Retrospective
+-------------
+With over 7k lines of code 10 releases, and more than 200 commits, Persimmon
+stands as a medium size codebase, since its inception it has gathered
+attention, with over 3000 visits, and more than 90 stars on [Github].
+
+<!--
+![Lines of code](images/loc.png)
+-->
+
+It has been featured on [multiple], [websites], and even won [best project] at
+the compshow 2017 at the University of Hertfordshire.
+
+![Chinese machine learning forum](images/china.png)
+
+Conclusion
+----------
+In conclusion Persimmon has achieved all proposed objectives, proving
 there is room for improvement on the field of visual languages for machine
 learning, and that small improvements make a significant impact on the user
 experience.
-Giving more power to the user should not mean making the interface more
-complicated.
+In fact a system should not only make it hard or impossible to construct
+incorrect graphs, but should make it easier and faster to create correct graph.
+
+Giving more power to the user does not mean making the interface more
+complicated, in fact it can be the opposite.
 
 
 Bibliography
 ============
 
+[Github]: htttps://github.com/AlvarBer/Persimmon
+[multiple]: http://mailchi.mp/pythonweekly/python-weekly-issue-295
+[websites]: http://forum.ai100.com.cn/blog/thread/ml-2017-05-10/
+[best project]: https://twitter.com/HertfordshireCS/status/857266574356598785
+
 [^REPL]: A Read Eval Print Loop is an interactive console many modern
     programming languages that allows for the interactive execution of
     expressions, saving the results in a local session.
+

docs/images/full_use.gif

@@ -9,14 +9,15 @@ import pathlib
 
 
 kv_files = glob('**/*.kv', recursive=True) 
+png_files = glob('**/*.png', recursive=True)
 
 non_python_files = []
-for file in kv_files:
+for file in kv_files + png_files:
 	non_python_files.append((file,
 	       str(pathlib.Path(*pathlib.Path(dirname(file)).parts[1:]))))
 block_cipher = None
 
-non_python_files.append(('persimmon/connections.png', '.'))
+#non_python_files.append(('persimmon/connections.png', '.'))
 
 a = Analysis(['persimmon\\__main__.py'],
              pathex=['persimmon'],

docs/images/smubble.gif

@@ -1,10 +1,11 @@
 import sys
-if (len(sys.argv) > 1 and
-    (sys.argv[1] == '-d' or sys.argv[1] == '--debug')):
-    import coloredlogs
-    coloredlogs.DEFAULT_DATE_FORMAT = '%H:%M:%S'
-    coloredlogs.DEFAULT_LOG_FORMAT = '[%(asctime)s] %(name)s - %(message)s'
-    coloredlogs.install(level='DEBUG')
+if len(sys.argv) > 1 and sys.argv[1] in {'-d', '--debug'}:
+    #import coloredlogs
+    #coloredlogs.DEFAULT_DATE_FORMAT = '%H:%M:%S'
+    #coloredlogs.DEFAULT_LOG_FORMAT = '[%(asctime)s] %(name)s - %(message)s'
+    #coloredlogs.install(level='DEBUG')
+    import logging
+    logging.basicConfig(level=logging.DEBUG)
 if hasattr(sys, '_MEIPASS'):
     import os
     os.chdir(sys._MEIPASS)