Idea. Constructor sites in the dialogue mode

Describing your idea, there are always fears that it is not at all new or its implementation is impossible at all for some reason hidden from you. Nevertheless, I want to offer the community an idea of ​​a new approach in web development of simple sites.

Immediately I will warn you, in the post we will discuss the development of "typical sites". It is clear that developing a serious website or service requires deep knowledge and experience. But the development of blogs, business cards, portfolios, catalogs, small shops, etc., could easily cope with the average Internet user. If I knew "How?" ...

Idea

The point is to develop a site giving short commands in "almost natural" language. That is, the language is as close to natural as possible (as far as AI allows).
')
Instead of learning some constructor, learning terminology, learning the basics of html / css / php / js / layout / ..., etc. you can simply open the template you like and start changing it with simple commands.

How can it look like?

1. User saves DialogCMS files on server
2. Appeals to the site, the start screen may look like this.
   
   
3. Suppose the user started with a blank page. At the top of the screen, he sees the system panel.
   
   
4. The user enters one or more commands, possibly using voice recognition. The system analyzes the commands and "translates" into a formal language. If the user agrees with the "translation" - he confirms the command, if not - reformulates the request.
   
   
5. The system in response to the commands configures the site.
   
   
6. The user can customize the site. In this example, it changes the color of the header (hereinafter, the command and the result will be shown in one picture)
   
   
7. Having selected with the mouse any element of the site, the user can work with it - move, resize, change the code, etc. In this example, the user with voice command will add a shadow to the logo.
   
   
8. By giving simple commands, the user further changes and configures the site.
   
   

There may be the impression that everything described is easier to do in the constructor than through dialogue. In part, it is - you can change the color of the caps and use the context menu. But the proposed approach is much broader.

One team can add a new module, section or widget, you can connect bootstrap, or "add an animated gallery." You can view performance or set a attendance counter, set up an account, a registration policy, backup, localization ... and so on.

The user can click on any text - rewrite it. It can easily "make everything brighter" or "try it in blue tones" or "hang on the main slider" or "add a link page" ...

In essence, the system (ideally) corresponds to the “super-enhanced interface”, where everything is called as the user assumes. But the user of this interface does not see, and therefore is not afraid)

The point of the system is not to give an absolutely universal tool, but to help a person far from IT to quickly create a simple website, check their thoughts and ideas. Someone may be satisfied with such a result, someone will understand that the system’s capacity is not enough for him and will order revision from the prof. a designer, someone generally uses the system only to create a prototype, run in user scenarios and sit down to write TK for a normal studio already understanding what he wants ...

How can this work?

Now I will describe how in my opinion this system could work.

At first glance, it seems that it will be very difficult to analyze commands in natural language, even taking into account the limitations of the system. But analyzing typical commands a fairly simple algorithm emerges.

1. We find typical phrases such as “play with fonts”, “rubber design”, etc. execute them.
2. We bring all the words to the initial form.
3. We are looking for word-elements: “heading”, “basement”, “logo”, “telephone”, “name”, “page”, “selected”, “current”, “link” ... etc. There will be quite a few such words and they will be described in the basic structure of the site.
4. We are looking for word-clarification: "left", "right", "below", "above", "above", "under", "in", etc.
5. We are looking for property words: "background", "color", "font" ... etc.
6. We are looking for meaning words: "green", "blue", number, string in quotes ... etc.
7. We are looking for word effects: “shadow”, “gradient”, “glare”, “italic” ..., etc.
8. The rest of the text is thrown out, broken down into sentences, enumerations (words of the same type, separated by commas or “and”) - we divide them into independent phrases (we duplicate the words of the phrase outside the enumerations).
9. Alternately compare phrases with samples. Such as:
   a. clarification1 + element1 + element2 -> element2, placed near or in element1, in accordance with specification1.
   b. property1 + element1 + value1 -> For element1, the value of property1, to make equal to value1
   c. element1 + property1 + value1 -> the same as in b
   d. value1 + property1 + element1-> the same as in paragraph b
   e. element1 + value1 -> element1, change the content text to value1.
   f. element1 + effect1 -> for element1, add effect effect1.
   g. Etc…
   
10. At the output, we get a set of commands for the configurator, and a set of corresponding phrases in a "formalized language" for display to the user.

Note This algorithm is of course simplified and corresponds to the mode of site creation. In addition, there may be, for example, the administration mode, and the text editing mode. This separation will allow more accurate interpretation of user commands.

You can process requests in the cloud, which will allow you to actively develop the analyzer and add new phrases (including new phrases users can add).

A formal response for the user and commands for the configurator is returned from the cloud.

Configurator, I think it makes sense to do three levels:

1. The first level is abstract. Here are all the elements of the site, assigned / change their properties, relative position, etc.
2. The second level is structural, it should include descriptions of pages in the “markup language”, like what I described in my first post habrahabr.ru/post/167525 . The point is to have an easily editable structure representing the entire site. Based on this structure, the base code of the site is generated.
3. The third level is the code level. At this level, an advanced user can make changes directly to the site code. For example, editing an element in Chrome - transfer css-properties to the properties of an element. Also at this level various “chips”, libraries, decorations, etc. can be connected.

This design will allow any team to easily transform into changes at each level. After that, a structure is formed on the basis of the 1st level, and changes from the second level are made to it. The site code is formed from the structure, which is supplemented with edits stored at the third level. At the exit we get the site code.

Advantages of the system:

1. Extremely low threshold of entry. In fact, any Internet user can create a website for himself. If he expresses his thoughts in a completely non-standard way - something does not prevent to look into the list of typical phrases and to understand the terminology of site building with examples.
2. Self-study. In the course of developing the site, the user sees how his phrases become “correct”, which teaches him to use the correct terminology, etc.
3. Flexibility. Unlike typical designers, the complexity of the site can be much higher.
4. New technologies. Using simple commands, the user can connect libraries and frameworks to the site without analyzing in detail their work and integration with other parts of the site.
5. Alternative uses. For example - rapid prototyping.

Minuses I will not list in detail :)
The main ones, in my opinion, are: the complexity of implementation, possible security problems, and other nuances associated with the fact that the user doesn’t really understand “what he is doing” ...

Why is this necessary?

The most difficult thing for a beginner is often not some specific questions, but a lack of a common understanding of the process, concepts and terminology. He simply does not know that the line where he enters the text in order to find something can be called, for example, “the display module of the search form widget” ...

Note As an abstract example. I often observe how beginners and even confident users try to do something not quite standard in Word or Power Point. Knowing about how the team can be called, they go through half the tabs of the menu by pointing the buttons and reading the tales ... whereas with such a “voice assistant”, one could simply say “make this picture darker” and that's it.

For beginners there are many different designers, but they do not help much. Or the user should restrict himself to an elementary template without the possibility of fine-tuning. Either the designer requires no less time to study than any CMS, while being far behind the latter in flexibility.


As an example: a well-known site builder, has this interface right after the user registers a new site. It’s not easy for a newbie to figure it out on their own.

The problem is that the user must first understand what he wants to do, present it, describe it in the correct terms, and only then begin to do it. This approach does not correspond to the very idea of ​​a novice constructor.

Thoughts on implementation.

At the moment, everything is only at the level of ideas, albeit more elaborated than it was possible to describe here. If like-minded people appear, I will be glad to talk about implementation.

I think there are two possible options - either the development of CMS from scratch, or a superstructure over an existing CMS, such as Drupal. Considering the enormous possibilities of Drupal to expand the functionality, but a relatively high “threshold of entry”, I think such an “intelligent addon” would be very interesting for novice users.

In the future, with a developed system of analysis of commands in natural language in the cloud, we can consider other areas of work, where complex interfaces and concepts scare novice users.

Upd
Judging by the comments, I seem to have poorly formulated the main idea of ​​the system, fascinated by the details.

Therefore, I emphasize a few points:

1. I do not propose to return to the time of consoles. On the contrary, I propose to move further in the direction of intellectual development tools.
   Ideally, for me, I tell the system what site I want - and it builds it in real time ... I make corrections, experiment, etc. All this without terminology, rules, commands, steps, etc.
   As far as possible now - I tried to present in the post.
   
2. Teams can be very non-standard. Since the system takes into account the current configuration, the presence / absence of elements on the screen, etc. - you don't need a strong AI to understand what the user wants at the moment
3. The proposed system does not replace the usual CMS, but complements it. The user can customize the site through the usual toolbar, edit texts and elements like the one implemented on wix.com. But when he is confronted with something incomprehensible - he can ask a question to the system and immediately solve the problem, and not look for information on the forums, and not think how to apply knowledge in this particular case ...
4. Voice input is only an input option. The user can enter commands with text, and “visual commands” simply execute in an editor like wix.com