Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/wavesoft/web-ng

A workbench on how the new generation of the web could be
https://github.com/wavesoft/web-ng

Last synced: about 2 months ago
JSON representation

A workbench on how the new generation of the web could be

Awesome Lists containing this project

README 

        
web-ng

======



An attempt to create a better information browsing on the internet, by redefining most

of the components of the current system. That's the New Generation of the web.



Here is what's around:



* The folder **browser/** contains the sources of the WebNG.

* The folder **browser/dist/** contains the latest jar of the browser.

* The folder **browser/app/** contains binary packages of the latest build.

* The folder **webng-demo/** contains the sources of the **gr.wavesoft.demo.hello** hello world view.

* The folder **documentation/** contains various documents and thoughts for the project.



If you just want to get started, check the *browser/app/* folder if there are builds for your OS, otherwise

download the entire *browser/dist* folder and run the *browser.jar*.



Description

-----------



This project consists of creating a new data representation language and a web browser that can render it. 

This new language contains only pure data and some hinting attributes that will define how the data are presented. 

In short, this project aims to **separate the data from the view**.



Components

==========



WebNL YAML Language

-------------------



WebNG fetches it's content over HTTP/HTTPS like a regular web browser. The data in the new web have no strict syntax 

but are structured. I picked YAML (Yet Another Markup Language) for this purpose, because it's human-readable yet fast 

in parsing. This gives a big bonus on the development side.



Here is an example of a small blog:



```yaml

~view    : gr.wavesoft.views.blog

posts    :

    - Title: New website

      Date: 2001-11-23 15:03:17 -5

      Body: |

          This is a demonstration on how easy you can create websites using

          the new generation of the web!

          

    - Title: Testing

      Date: 2001-11-23 15:03:17 -5

      Body: |

          Proof that HTML can still be used! 

```



Straight-forward right? Anyone can write (and even maintain by hand) this blog!



Additionally YAML provides node referencing and other cool features in the data language itself.

And of course, remote referencing of nodes is also possible:



```yaml

~view    : gr.wavesoft.themes.personal

title    : Welcome to my personal homepage

sections :

    

    - section: Blog

      ~src  : blog.yml

      

    - section: About

      ~view 	: gr.wavesoft.views.about

      name      : Ioannis Charalampidis

      contact   : @mailserver.com

photo     : images/profile.jpg

    

    - section: Big data

      ~src: big.yml

```



Ok, what about the view for this data set?



WebNG Views

-----------



Each data node, defined by the WebNG YAML Language is renderable. The author can pick any third-party rendering view available

on the internet to render it's node. It is not required to download or host that view!



WebNG Views are Java panels (Swing or JavaFX) that are referenced by their Fully-Qualified class name. I call them *Universal Views*

because they can be located and fetched no matter where they are if you know their name.



Here are some details...



### Introduction - Reasoning



The biggest problem with HTML is that it merged data and view in a problematic way. Even though there are revisions over

revisions, we still haven't seen the Web of semantics widely spread. Additionally, the aesthetics of the world has changed

so much that the simple HTML is not enough. That's why we have HTML5 right? CSS3 is indeed an awesome tool, Javascript with 

HTML5 has amazing new features... why then we have so many Javascript-assisting libraries? Why do we have boilerplates and

CSS themes just to get started? 



Additionally more and more people ask for security in the code and fast-executing javascript code. Yet we are still sending

plaintext javascript *source* code to the client.



In my opinion all of these problems, plus many more can be solved with what I call *Universal Views*.



### Universal Views



Universal Views are nothing more than Java Swing or JavaFX panels. That's it! We have a structured, visual representation of 

data with a technology that is already out there that has all the advantages we are asking for:



 * *Execution speed* - Java is compiled bytecode. It is transferred quickly and executed fast by the JVM.

 * *Code security* - We are transmitting bytecode. Reverse engineering (even if it is still possible) is now much more difficult.

 * *Browsing speed* - Downloading bytecode is much faster than downloading source code and compiling it.

 * *Powerful control over the view* - Forget about all the nasty javascript that you are using right now, just to make an image fade out. You now have full control over your view.

 * *Code security* - Java provides already sandboxing and protection over privileged code execution.



Now think the following: You have deployed your own Wordpress portal and you are maintaining your own blog. What about updates?

The *Universal Views* are meant not to be stored in the same server with the data. This means that they are maintained and updated

independently. This automatically means that the user is now (almost) free of security/server updates! (Almost means that the user

must still update the CMS back-end - if he is using any)



Data Structure

--------------



Since the language is not strictly-structured, The data layout depends on the view used. 

However, as a good practice it is recommended to define an abstract set of rules that the views will use.



For example, there might be many blog implementations. However the core syntax of all of them is the same:



    /posts = ARRAY[

		/title

		/body

		/comments = ARRAY[

				/author

				/text

			]

	]



Other implementations might add additional nodes, but all of them must implement these basic rules.



The language for this ruleset is not yet defined. 

You are free to submit your own ideas! :)



License

=======



This project is licensed under GNU General Public License 3

For more details see here: http://www.gnu.org/licenses/



Author

======



Main author and developer of this project is *Ioannis Charalampidis*

Contact me via Github if you have any suggestion or recommendation :)