Speed ​​up development with interactive blockchains

Since I started working on large, complex projects, I continue to affirm that there are two types of programmers - let's call them logics and visuals.

• Logicians are programmers with a classic flair. To get acquainted with the new technology, they go and read the documentation. The clarity of the code is increased, not a step to the left, not a step to the right. From the fence to lunch. The unpretentiousness of the convenience of working with the code is frightening - it seems that they can work with minified code, using only the search function.
• Visuals are people who approach the code more creatively, abstractly. To learn technology, they go to youtube and watch videos about dolphin lessons. In the code, it is important for them to divide into tangible blocks, the absence of sheets for 1000+ lines, the ability to implement in a new way. Performing a new task, they will shoot and search for their own solution instead of searching for the Internet already available on the open spaces.

This article will focus on a development tool, without which I, as a representative of the second type, no longer think of developing projects larger than 250 lines and which, I am sure, will be useful to our colleagues from the classical type - it was made in collaboration with one of you - the rising star of the programming world Stepan! So!

Aphs

Or Application Graphs is a flowchart editor
where blocks are editable snippets of code.

In a nutshell, this is an npm module that allows you, working on a functional whose code and context are scattered between several files, to combine it on one screen - without scrolling through 1000-line sources, constantly switching between files, searching for files in lists, holding just in my head. Aphs solves the problem of speed and complexity.



Honestly, I am surprised and perplexed why nothing of the kind has been invented in the entire history of programming - for a year I have been asking about something like this from my friends of different levels of programmer anger and I searched for it myself. Even in a super-convenient WebStorm, if you want the speed of switching between files, all you can offer is to do a separate Favorites Folder for each task, switching between files in which you will have to spend your brain and time resources each time to find the necessary line. How much torment in this line search!

Of course, in the same WebStorm there is the opportunity to walk around the blocks, clicking on their references - this is convenient, but this does not eliminate the other problem that Aphs eliminates - the need to keep everything in mind and not scatter while switching.

As an example: while working on one project, I came across a problem of many entities: when one function calls the second, the second - the third, the third - the fourth, the fourth - the fifth. And the second and fourth are used in several places and everywhere in different ways + all this is scattered between different files - it can take a pretty trivial task a day simply because it all fits in your head only with great difficulty and unhealthy level of cramp.

For this situation, Aphs will be useful from two sides: firstly, from the already explained one - when folding code from different files in one place and linking blocks with graph links, development becomes more obvious and faster, and only mechanical memory is used to navigate the code (hands remember where to panny, where was this or that block - right above or left below).
Secondly, all cases of using the second or fourth function can be taken out into a separate logical context and cleaned up within it.

What else might be useful for Aphs:

• Returning to one or another flow, you turn on the appropriate context (graph) and everything appears before your eyes without the need to painfully reconstruct the whole picture of this flow in memory. Reduces the risk of breaking something elsewhere while you understand it.
• As a documentation tool, sometimes not requiring tedious writing from exhausted switching between developer files. A new employee, having opened this or that context, will immediately see what is done at the beginning of the execution flow and how this affects what happens at the end.
• Starting work on a task with organizing a new flow for her is an easy psychological step, the first step and the basis for quick work. Like exercise in the morning.

I was very tempted to write this text without testing the functionality in battle, but I resisted and can say that I already use it in two projects. Of course, for a person from the side, its use will be less transparent, so I prepared a quickstart readme on a github and I’m going to describe the entire project’s device in more detail in the next article, but for now I'm ready to answer questions in the comments.

Already now you can use Aphs in any project organized similarly to a regular front-end project: at the root of the project are the src folders with your sources and node_modules, into which aphs is installed, from where it works.

The development has the following priority tasks:

• Get feedback, understand how relevant, what is clear and what is not clear
• Implement work with many contexts / flow (now only one)
• Make it more user-friendly (a lot of little things like changing the names of block identifiers from the client, and not in the code or excluding duplicate identifiers, etc.)

Therefore, if anyone wants to fill up a resume with open source or purely for the soul - welcome!
The server side is written in NodeJS, the client is written in AngularJS.

Just in case, github again: github.com/andreyselin/aphs