GCF (Generic Component Framework), based on Qt, allows developers to compose applications as a collection of components. GCF offers a ready made application architecture to

• manage loading, initialization and unloading of components,
• configure components using XML files and merge their GUI into a single application container widget
• help easily discover functionality offered by other components
• automatically download and install component updates from one or more update servers,
• communicate with components on other applications within and outside the host computer (IPC),
• create signal/slot connections between objects residing in different processes (IPC)
• load KParts and ActiveX components with ease
• load GCF components on GCF Application Server for remote access from HTML web-applications running in a browser

Today, we are happy to announce the release of  GCF – Version 2.6.  With this new release, developers can

• extend the format of GUIXML files
• explicitly specify and manage component dependencies in GUIXML files using <depends> XML element in GUIXML
• specify per-component stylesheets using the <stylesheet> XML element in GUIXML
• make use of specialized classes to manage QObject and IContainer pointer lists / maps
• offer access to web-services through CleanURLs
• use GCF with Qt 4.8 and Visual Studio 2010

The complete change log can be read here: http://www.vcreatelogic.com/docs/gcf-2.6.0/change-log.txt

We have made available source-code and pre-compiled binaries for Windows (Qt 4.8 with VS2010) from http://www.vcreatelogic.com/resources/downloads/. We invite you to download and use a copy of the latest version of GCF today!

We would want to have a really simple class that does all the serializing and parsing, so we declare a class like the one below.

struct JSONData;
class JSON
{
public:
    static JSON& instance();
    ~JSON();

    QVariantMap parse(const QString& string) const;
    QString serialize(const QVariant& value) const;

protected:
    JSON();

private:
    JSONData* d;
};

We begin implementing the class as follows. The static instance() method is implemented as

JSON& JSON::instance()
{
    static JSON theInstance;
    return theInstance;
}

That was easy! We now implement the constructor. One of the tricks we will be using in the implementation is this – we make use of the JavaScript JSON object to perform the serializeing and parsing for us. Towards that, we implement the constructor as follows

struct JSONData
{
    QScriptEngine engine;
    QScriptValue parseFn;
    QScriptValue serializeFn;
};

JSON::JSON()
{
    d = new JSONData;

    const QString script = "function parse_json(string) { return JSON.parse(string); }\n"
                           "function serialize_json(object) { return JSON.stringify(object); }";
    QScriptValue result = d->engine.evaluate(script);

    d->parseFn = d->engine.globalObject().property("parse_json");
    d->serializeFn = d->engine.globalObject().property("serialize_json");
}

Notice how we are creating JavaScript functions to parse and serialize objects. In the constructor we basically QScriptValues of the parse and serialize functions. Next, lets see how the parse() function is implemented.

QVariantMap JSON::parse(const QString& string) const
{
    QScriptValue result = d->parseFn.call(QScriptValue(), QScriptValueList() << QScriptValue(string));
    QVariantMap resultMap = result.toVariant().toMap();
    return resultMap;
}

Really really simple isnt it!

The serialize() function is equally simple – but for a CreateValue function dependency.

QString JSON::serialize(const QVariant& value) const
{
    QScriptValue arg = ::CreateValue(value, d->engine);
    QScriptValue result = d->serializeFn.call(QScriptValue(), QScriptValueList() << arg);
    QString resultString = result.toString();
    return resultString;
}

The CreateValue function basically converts any QVariant to a QScriptValue. QtScript module doesnt make it easy for us (no QScriptEngine::newVariant() is not useful here for all cases). We implement the CreateValue function as follows

QScriptValue CreateValue(const QVariant& value, QScriptEngine& engine)
{
    if(value.type() == QVariant::Map)
    {
        QScriptValue obj = engine.newObject();

        QVariantMap map = value.toMap();
        QVariantMap::const_iterator it = map.begin();
        QVariantMap::const_iterator end = map.end();
        while(it != end)
        {
            obj.setProperty( it.key(), ::CreateValue(it.value(), engine) );
            ++it;
        }

        return obj;
    }

    if(value.type() == QVariant::List)
    {
        QVariantList list = value.toList();
        QScriptValue array = engine.newArray(list.length());
        for(int i=0; i<list.count(); i++)
            array.setProperty(i, ::CreateValue(list.at(i),engine));

        return array;
    }

    switch(value.type())
    {
    case QVariant::String:
        return QScriptValue(value.toString());
    case QVariant::Int:
        return QScriptValue(value.toInt());
    case QVariant::UInt:
        return QScriptValue(value.toUInt());
    case QVariant::Bool:
        return QScriptValue(value.toBool());
    case QVariant::ByteArray:
        return QScriptValue(QLatin1String(value.toByteArray()));
    case QVariant::Double:
        return QScriptValue((qsreal)value.toDouble());
    default:
        break;
    }

    if(value.isNull())
        return QScriptValue(QScriptValue::NullValue);

    return engine.newVariant(value);
}

Thats it! You can now simply make use of JSON class to parse and serialize JSON objects.

// Parsing json strings
QString jsonString = ....
QVariantMap jsonObject = JSON::instance().parse(jsonString);

// Serializing json objects
QVariantMap jsonObject = ...
QString jsonString = JSON::instance().serialize(jsonObject)

How many developers are we looking to hire?

We are looking to hire 3-5 developers. What does that mean? It means that we are going to hire 3 developers at-the-minimum, because we are in urgent need of 3 developers for working on our products and projects. Over and above that, we have budget to hire 2 more developers who can work on projects that are currently in ideation stage and need a lot of developer love to bootstrap. This means that developers will have a mix of production and research work over here!

How we attempt to asses the quality of a developer?

We are looking for Qt/C++ developers and not BE/BTech/ME/MTech/MS/PhD holders. So, as far as we are concerned we honestly dont care if you were a university topper or if you flunked several times in college. What we __do__ care is whether you can write good Qt/C++ code or not. That’s really really it!

The way we asses the quality of a developer is by giving him/her a programming challenge. Because You do not truly know someone until you fight them.

If a developer has already been making good contributions to a open-source project and if we can have a look at it; then we are more than happy to talk to you about our offer without giving you the programming challenge!

The programming challenge we give you is usually an application/problem that you write/solve using Qt/C++ – within a time frame of 2-3 hours. The programming challenge is usually held in our office, because it gives prospective team members an opportunity to have a look at our office and get clear/comfortable with what our office has to offer. We dont have a large office building with glass doors, swipe cards, coffee/tea stations, canteen etc. We have an office that has comfortable tables and chairs for developers to sit and work. We have a TT table to steam out. There are quite a few hotels / fast-food places nearby where you can buy coffee/tea/milk/soft-drink/food. For people who dont reside in Bangalore or anywhere near Bangalore, we send them the programming challenge over email and expect to hear from them within one working day.

While working on the programming challenge, you can

• Use any sort of documentation resource (books on Qt/C++/Philosophy/Yoga/Cooking etc.., Qt Assistant, the Internet)
• Use any IDE/build system. We use Qt Creator at work, but you can use any IDE of your choice, as long as you dont force us to buy licenses of them for you AND you dont install any Pirated software on our (of for that matter your own) computers.
• Copy/Paste relevant parts of any sample code you can find in Qt source code and/or any other resource on the Internet. But make sure you dont copy any copyrighted/patented material.
• Ask us for help/clarifications. [However, if you ask us - how do we solve this problem? OR how do we write this application? --- you can expect nothing more than a frown from us!]
• Take a coffee/tea break in the middle or go for a walk to crystallize your ideas/algorithms for solving the problem.
• Go to the loo or even comfortably sit there.

So, we expect you to work on the programming challenge in a real development environment.

After attempting the programming challenge,

• We expect to get a complete and working solution written in Qt/C++. However many times we are happy to talk to you about our offer even if your solution is only partially complete. We are as much interested in your approach as we are in the final solution.
• We take a look at the way you write your code. Things like indentation, function/variable naming conventions, comments etc..
• We ask questions on the code you have written. For example, things like – why did you choose this approach over another approach.

The programming challenge

Programming challenges are typically small problems that we pick up from one or more of our existing projects/products. We pick our a small problem and generalize it so that you wont have a clue as to where the problem came from. We try to keep our programming challenges interesting and fun; so that you can enjoy working on them as well. The programming challenge is not a complicated problem, it is not a blatantly simple one either. It gives us an opportunity to take a look at how one approaches a problem.

For example, one of the programming challenges that we have been giving out for the past month or so is this.

Write a widget called PuzzleWidget that can take any image, divide it into a 4×4 grid puzzle for users to work and assemble the tiles into the original image. For example, consider an image as follows (filename = image.jpg):

We write a program as shown below that makes use of the PuzzleWidget class.

#include <QtGui>
#include "PuzzleWidget.h" 

int main(int argc, char** argv)
{
    QApplication a(argc, argv); 

    QImage puzzleImage("image.jpg");
    PuzzleWidget puzzleWidget;
    puzzleWidget.setPuzzleImage(puzzleImage);
    puzzleWidget.show(); 

    return a.exec();
}

When the above program is compiled and executed, we get a window in which

• the given image is split into a 4×4 grid
• one of the tiles (in the 4×4 grid) is randomly removed
• the other tiles are randomly dispersed
• the user can click on a tile next to the empty spot to move it.
• by repeatedly rearranging tiles, the user can reassemble the image.

Take a look at the expected output.

In our office, the lowest time taken for implementing a complete working solution for the programming challenge above is 12 minutes. On an average developers take about 40 minutes to come up with a complete working solution. The complete program is about 200 lines of code. This means that 3 hours is more than sufficient to work on the programming challenge.

Why do we take the programming challenge?

Because You do not truly know someone until you fight them. Moreover the projects/products that we are working on requires our developers to come up with solutions on their own. We require that our developers can produce results on their own as-much-as-possible. At the moment, we do not have the capacity to give training on Qt/C++ to hired developers. We also do not have the capacity to pre-solve problems that we face in our products/projects, explain the solution and then just expect team members to simply write code for it. We need our team members to create solutions by themselves for the most part. The programming challenge, for us, is the best way to figure out if we can work with a prospective candidate or not.

Note to prospective candidates

We welcome you to consider joining our company. We would love to hear from you! We will do as much work as possible to keep you happy in our company. In exchange for that, we would really love it if you can CODE! Our request is that – you take a look at this blog post, and attempt the above programming challenge by yourself. If you are confident, then please drop in an email expressing your interest to join us. We will then have a phone conversation with you and invite you for taking up the programming challenge. If you are through with that, WELCOME ABOARD!

Over the last week, we have implemented Clean-URL access to objects and their methods. For example, when we launch GCFApplicationServer and click on the system-tray icon, we can see the application server window with information about all the objects and methods available on it. One of the sample server components bundled (as an example) with GCF 2.5, is the FractalService component. This component has objects MengerSquareFractal and SierpinskiTriangleFractal. Both of these objects offer a method called generateFractal, which can take as parameters the iteration count and image-size. Once called, the function returns a fractal-image.

Until 2.5.0, to access the generateFractal method in either FractalService.MengerSquareFractal or FractalService.SierpinskiTriangleFractal; we had to either write a web-application with some javascript that made use of GCFMessage.js to call the method and show its output — OR — we had to write a Qt/GCF desktop application to make an asynchronous call either using GCF::RemoteObject or using GCF::RemoteAppAccessPoint. Now, we have yet another approach: Clean-URL access.

We can now, simply launch a browser and type a URL into the address-box in the format

http://{host}:{port}/{component-name}.{object-name}.{method-name}/{param-1}/{param-2}/{param-3}....

Where,

• {host} – is the server on GCFApplicationServer is running. localhost if you are testing it on your own computer.
• {port} – is the port-number on which GCFApplicationServer is running. 4232 by default.

The remaining parts are obvious.

So, if we want to call on FractalService.MengerSquareFractal object, the generateFractal() method with iterations as 6 and image size as 400; we can simply construct a Clean-URL as follows and type it into the browser – and see the result in the browser itself!

http://localhost:4232/FractalService.MengerSquareFractal.generateFractal/6/400

The output would be

The resulting output is a GCF-XML message. This message can then be parsed and used on the client side. On the other-hand if you just need to see the result as output in the browser itself; you can just the following url

http://localhost:4232/RESULT/FractalService.MengerSquareFractal.generateFractal/6/400

Checkout/Update your copy of GCF from the SVN and take a look at this for yourself!

We are looking for developers who have working experience in developing Qt/C++ applications to join our team, that creates desktop software for diverse domains.

Our Work: Our flagship product is Generic Component Framework or GCF. GCF, based on Qt, allows developers to compose applications as a collection of components. GCF offers a ready made application architecture to manage plugins, automatically download and install software updates and communicate with applications within or beyond the host computer system. The last version includes a tool called “GCF Application Server” using which developers can now create and host GCF components for access from a web-application. We are looking for developers to join us, further develop GCF and build solutions around Qt/GCF for our customers.

Work Culture: At VCreate Logic, we have a very open work culture. You will know every one in the company and will be a part of key decision making processes. In short you will be the company

Hiring Process: Our hiring process is simple – we first process the resumes that we receive. Short-listed developers will be personally contacted to know more about their work experience. If we can take a look at any code that you have developed – then great, otherwise; we will send across a Qt/C++ based programming challenge via email. You can revert back with your code for the programming challenge within 48 hours and we will get back to you after evaluating your code.

If all of this sounds interesting for you, send your resume to careers@vcreatelogic.com.

About Us: We are a software products and services company, based out of Bangalore (India). For the last 6 years we have been developing applications for different domains (like Medical Visualization, EDA and Radar Display) using a combination of Qt/C++, OpenGL, VTK and our home-grown product GCF (http://www.vcreatelogic.com/products/gcf). Going forward we have plans to further the capability of GCF in allowing developers to make available their Qt/GCF components available as web-services – there by enabling developers to take their Qt/Desktop applications to the web! We are also currently working with companies that are using GCF for development of large visualization applications. For more information please visit http://www.vcreatelogic.com/home

Going forward we want to be very neat and clean about bug reporting and tracking. Towards this we now have a flashy new web-site: http://bugreports.vcreatelogic.com. This web-site is built using Bug Genie. From now on anyone can register in that web-site and post their bug reports / feature requests. From our-end, we are committed to attend to all reports/requests posted by users of GCF – both commercial and open-source users. Commercial users will ofcourse be given preference!

Very soon we will be coming up with discussion forums and mailing-list infrastructure to help make communication between users and developers easy and productive.

GCF (Generic Component Framework), based on Qt, allows developers to compose applications as a collection of components. GCF offers a ready made application architecture

• to manage loading, initialization and unloading of components,
• to configure components using XML files,
• to merge GUI offered by different components into a single application container widget,
• to have components easily discover functionality offered by other components,
• to automatically download and install component updates from one or more update servers,
• to communicate with components on other applications within and outside the host computer (IPC),
• to create signal/slot connections between objects residing in different processes (IPC)
• to load KParts and ActiveX components with ease

Today, we are pleased to announce the availability of GCF Version 2.4.

The main new feature in this version is the “GCF Application Server” tool. Using this tool developers can now create and host GCF components for access from a web-application. This means that you can now create web-services using Qt/GCF and write AJAX style web applications to call on methods exposed by objects in your GCF components. Visit http://www.vcreatelogic.com/docs/gcf-2.4.0/html/gcfappserver.html to know more!

In addition to the above key new feature, the latest version of GCF

• works with Qt 4.6 and Qt 4.7 (infact the minimum requirement is 4.6)
• has an updated plugin to help to create GCF applications using Qt Creator 2.0.1. Pre-compiled binaries (Windows and Linux) for Qt Creator 2.0.1 available.
• enables IPC over HTTP protocol

Download the latest release of GCF by visiting http://www.vcreatelogic.com/resources/downloads/.

About VCreate Logic: VCreate Logic (VCL) is a visualization products company based in Bangalore, INDIA. VCL provides products and solutions to help build large visualization software. Their flagship products are Generic Component Framework (GCF) and VTK Designer. VCL also provides expert consultancy services in areas of Qt, GCF, OpenGL, VTK and OpenHaptics. For more details please visit http://www.vcreatelogic.com.