Here is my list of ideas that are related to Wt, maybe they would fit for Wt GSoC 2010.

1. as about qt-wt integration: Considering that even well tuned browsers like the webkit based ones on embedded devices, would make sense to create a rendering engine for wt, that interacts with the Qt Declarative UI (QML). Such a combination would result in a very fast client and very fast server for deploying services on embedded devices

2. Implement WSqlQuery/WSqlModel etc family, as QSqlQuery/QSqlQueryModel . The Wt::Dbo family is nice, but they do not provide at the moment the integration with views.

3. The already proposed idea about using Qt Designer to design Wt widgets, might be a wrong direction. In my opinion a better solution would be to create a Wt application that would allow the construction of “empty” widgets, through a web application. The advantage of this approach is that contrary to Wt Designer, the widgets would render on the final web application as they render in the Wt. The product of this designer wt application would be a html template. Any .ui interface etc. would mean unnecessary overhead in the development cycle etc. etc.

A new open-source project started: babelengine. The intention is to design and implement in C++ a highly modular web 2 application framework (CMS, but not only). The framework will make intensive use of the existing WT toolkit.The framework will include powerful language and translation features and should become a powerful tool for multi-language web platforms. Thus the name babel-engine. I hope you will like the name :).

At the moment http://babelengine.org will host a forum, where we can discuss ideas, features, plans about the project.

DC (I do not know if he wants his name being published), implemented a mechanism that allows to assamble the widgets of a generic WT application with help of an XML file. I was thinking to do something similar, I even made reference to it on my earlier post on the mailing list. I was not sure that xml was the best choice. My idea was to create a “wrapper html” file, the stuff that web designers love, and position inside this html file the different controls. This html file would have been the root control, and the application would have assembled the widgets based on the information contained inside the html file. So again this html file would have been the design html for web designer and also the “imput file” for the programmer. Anyway the implementation that DC started is fine, as from the “layout” html file I was mentioning above one could generate the xml configuration file.

After DC published his work on the mailing list I made some comments about some details nice to have.

• a mechanism to connect signals with slots
• a mechanism to specify data sources for the widgets

I am afraid that I was not understood regarding the data source. I was writing earlier on the mailing list also about database connectivity, and libraries that would allow such connectivity (I called it data source). Choosing a good database connectivity engine (library), and linking against our generic program, it would be interesting to configure in the same XML file the database and table name (and eventually sql statement) that would feed a certain widget. Exactly as our funny friends Visual Basic or Delphi did. Example, you add to your XML file a new combobox with some country names. You do not want to add code that would only feed the control, recompile, etc., but you would rather specify it in the xml file for that widget something like as “<datasource database=”blahblah” table=”countries” row=”name”/>. When building the widget if such datasources are specified,  with some simple and generic mechanism the widget would be loaded with the “name” column from the countries table.
Or something similar, once the combobox with countries loaded, you add a text view control, and link the <selection changed> signal of the combobox with some slot in the text view control. The view control would have sthg. like <datasource database=”blahblah” view=”select description from countries where name=***selected country***>.

Unfortunatelly I do not have time to go deeper into details, I would love to do so, I would love to find myself the solution, but I believe this would make wt much more fun to use… even for beginners.

I think it would be also a nice marketing stuff for WT. Create wt application in 3 steps. The user would have to download the “generic executable” (that is what windows kidZZ love ). Run the executable, it would open port XXX. Then go with browser, http://localhost:XXX/admin. The admin page will show you a simple start control, and some mechanism to add/remove controls, specify signal slot connections, etc. What would be the next step… add some simple python/ruby code to add more functionality ?

Hm… I do not think this is a dream… Isn,t it?

in an elegant design a web applications presentation layer (or equivalent ones) should not make tricks about caching. I see often bad code like following everywhere, especiall written by php kids:

HTML Page::getHtml() {
if(cached)
data = getFramCache()
else
data = getDataFromDatabase()
}


one should create polymorfic database, or use templates to hide caching in the data source pattern.

Widget::onEvent(IdClass id)
{
Datasource *datasoure = Datasource::singleton();
datasource->getData();
}

Datasource::getData(Key &key)
{
//do some sql
}

then you could have
class DatasourceWithCache: public Datasource
********
Data *DatasourceWithCache::getData(Key &key)
{
Data *data = getFromCache();
if(!data)
Datasource::getData(key);
return data;
}

The cache could be shared between threads or processes (!!security issues!!), or just one process.
Your framework should initialize the singleton with the correct datasource. You could create a config file, and specify the activation of the cache. You can implement a datasource based on sthg. like memcache (so much venerated by php kids).

Let’s take a simple example with a web application that would have different views (pages) of the same table data. If you change one cell in the table, all the other cached views should be invalidated in the “classical” approach, whereas with ajax approach, you should invalidate the cache only for that particular cell. If this level of cache is not enough, you could always find a compromise and with a bit more complex cache, one could cache the whole rendered widget data, but here the widget code itself would probably need to help. (and thus a bit in contradiction with the first statement). Anyway there should be a balance between the necessity of the cache.

Another example, a wiki engine, or blog engine. With wt, one would need to cache the pages data, not the decoration around. The decoration would not change during going from one page to another one. So one could specialize the datasource by providing rendered (converted from wiki syntax to html). And thus one would just feed the wiki widget with cached data.

wt rocks…:).

It has the standalone http server engine, it has also fcgi implementation.

It’s value would probably be significantly increased if some generic database access would be provided (some crazily fancy templates, or polymorfic DAO classes, that could be inelligently connected to widgets. (Yes, the way microsoft does with ocx controls). Another obvious requirement would be to support differet database backends. 

There are some libraries out there, everyone with pluses and minuses. Myself I was spending some time to understand what would fit the best. After studying these libraries I found that on boost’s mailinglist there was already a discussion about the topic. I will write my conclusions soon, but I wanted to ask the wt commmunity what each one uses, and if it would make sense to invent a something and eventually integrate into wt.

the following libraries can be found on internet:

• Dtl (http://dtemplatelib.sourceforge.net/)
• Otl (http://otl.sourceforge.net/)
• Mysql++ (http://www.tangentsoft.net/mysql++/)
• socci (http://soci.sourceforge.net/)

So, can we use or learn something from these libraries?

the only needed libraries for wt are:

• libboost_thread
• libboost_program_options
• libboost_signals
• libboost_date_time
• libboost_filesystem-gcc42
• libboost_regex
• libboost_system

Therefore one should run the configure script for boost as

../boost/configure –without-icu \

–with-libraries=thread,program_options,signals,date_time,filesystem,regex,system \

–prefix=`pwd`/deploy