Are browsers as we know them today a phase-out model? Can we use the web without it? The answer to the second question is yes. Are Headless Browsers Killing Web Design?
Headless browsers: ui without ui
Headless browsers have been around for about a decade. They are applications based on standard rendering engines (chrome, webkit, gecko) and can display web content without actually displaying it. They lack a visual user interface; they are headless.
Initially, headless browsers were developed for quick and automated testing of websites. Typically, this is achieved through a call-level interface (Cli) or a defined interface (Api). Upon request, error messages are sent as screenshots, or in other specified ways.
Since the introduction of headless browsers, the developer community has split them up. Some argue that the technology is pointless, but will test their designs and applications on a range of "normal" browsers. This is reasonable.
After all, visitors to this bid won't be using headless browsers either. n.PhantomJS it's one of its most popular types, it also produces error messages that don't exist in regular browsers. This is only partially useful.
PhantomJS: One of the most popular headless browsers.
Node.js is also very popular with the creators of headless browsers as a server-side underlying technology. Some kind of modern specimen of this type is n.ZombieJS as the name here already suggests. Contrary to what the name suggests, ZombieJS is said to be very fast, making it an excellent choice for high-performance testing.
Confident users of headless browsers appreciate the ability to run large numbers of automated tests through the headless browser, or run entire groups in a quick and intuitive way. The main proponents of headless browsers are developers developing complex web applications for large target audiences.
The average web developer, with a modest product and client reach doesn't really need economies of scale, which means he's likely to choose the traditional path.
Headless browsers: Google puts it to good use
In 2009, search engine giant Google thought about a headless browser. in a very different way. Californians face the problem of not being able to index content that is dynamically generated. Ajax. In the end, that content just becomes an indexable website because we need the browser to render them properly and be legible.
Therefore, search engines need an internal browser to make content available. Done as soon as you say it! Google has since used headless browsers, allowing them to read content that requires front-end interaction, as long as the page operator takes some precautions. bing is using a similar technique.
Now that there are more and more browser engines, what does it mean for headless browsers? Yes, they are also growing more and more.
Progressive web apps (PWAs) show where we're going
One of the core technologies of every progressive web application (PWA) is the so-called service worker. It's a javascript that is able to perform the function without the website having to be called. You can find some more detailed explanations in the article mentioned above.
Service workers are part of the headless web itself and can be used by headless browsers and clients. This will turn the headless browser into a service that handles server-side programming. This can make the browser on the visitor's side redundant.
On the conversion of web content into modules
Headless browsers have pre-rendered content. These rendered web content fragments can be used for further processing as well as for display. It doesn't necessarily have to use a browser to display them correctly. Meanwhile, a native app can process the entire presentation and display a structured layout of pre-rendered web fragments in its own UI.
Examples of these methods are Facebook Instant Articles or Google's amp project. In the article mentioned above, I pointed out that Google should have a special interest in securing the open web. amp is a building block. However, it did not receive unrestricted approval.
Google's amp-project.
Web push notifications (as seen under Google OS android) go in the same direction.
Microdata is also an essential factor. You could say that even today there are ways to transfer data via json, for example, you are right. However, the headless web needs to go a few steps further, as it not only fetches data from the switching interface, but also the entire functional module, including the integrated program logic components.
To do this, attention must be paid to semantically correct markup, creating building blocks that can be used sensibly.
Now you can also web push as saas for book publishing as shown
Advocates of open networking standards may enjoy this. I think it's safe to say that these open standards will gain significance in the future.
However, thanks to the triumph of open web standards, the joy of the average web designer may soon fade away. After all, traditional web design is no longer necessary, and the architectural aspect has started to become more of a focus. This aspect becomes very clear when looking at the amp. Standardized display and delivery of content via Google servers is not to everyone's taste. The project is somewhat controversial, but is almost entirely supported by the publisher. Content providers seem to like it.
So, does this mean that the design and development fields will be more separated? Today, at least in front-end development, we still see a fusion of various disciplines. This has already started, the web designer installs the software on the server and adjusts the cms theme so that it can display dynamic content correctly.
Speaking of headless, we should also mention that the CMS trend continues. Can even run wordpress and WooCommerce headless without a frontend. In normalized form, the content can be extracted from the backend and used in any desired way, such as a native application, especially for the mobile device.
In addition to well-known market players, there are solutions from the start that allow them to operate without legacy burdens. One example is: n.ButterCMS which exists in google cloud; another example is Kentico cloud which also runs as cloud saas.
Currently, there is no workaround to scale headless browsers so they can serve thousands of instances simultaneously. This technological barrier will surely disappear in the future, but it still exists for now. At least until then, sane websites won't become redundant.
Friends who are interested in technology can add me QQ skirt: 213126486 Invitation code: Leaves, discuss progress together~