Running Qt + MySQL application

29 Mar 2015

Yesterday I tried to run my university project made with Qt and MySQL. But all I got was strange error message, saying QMYSQL driver is not loaded whilst loaded driver list actually included that one.

Searching all over the internet up until 2AM and recompiling the whole Qt gave no result except time being wasted. Yeah, and 90% of search results were tutorials on how to recompile Qt MySQL plugin under Windows.

Yet in the morning I found solution and it was beautifully simple! I just performed one step from Deploying Qt applications, actually just copied the plugins/ directory to the dir where the application executable lives (build-debug/ or build-release/ for my project; I hate the default build-#{ProjectName}-Desktop_5_4_1-Debug/ paths); included the sqldrivers/ directory there (just copied) and created (a bit tuned although) the qt.conf file. That file just pointed the plugins path to the custom one:

[Paths]
Prefix=.
Plugins=./plugins

To sum everything up:

create a plugins/ directory in your build directory
copy Qt/5.4/Src/qtbase/plugins/platforms/ there
copy Qt/5.4/gcc_64/plugins/sqldrivers/ there too
create qt.conf file in build directory and fill it as mentioned above

And one more hint before the end: to debug why your Qt plugins fail use this application startup switch: QT_DEBUG_PLUGINS=1 ./app_name - this will display plugins debug information.

Tiny java code...

27 Mar 2015

This one was super easy so I did a quick comparison of a couple of ways you can do it; the goal is to count all the alphanumeric (a-zA-Z0-9) characters in the text of a Sherlock Holmes book. There’s probably other ways do do it because there’s lots of ways to do literally anything, but the fastest one here is stripping out all non-alphanumeric characters (\W).

//*********************************************//
//                                             //
//        EASY DAILY PROGRAMMING TASK #19      //
//        ALPHANUMERIC CHARACTER COUNTING      //
//                                             //
//*********************************************//

public void count1(String text) {
    long start = System.currentTimeMillis();
    int count = 0;

    for (char c : text.toCharArray()) {
        if ((c + "").matches("[a-zA-Z0-9]")) {
            count++;
        }
    }

    long end = System.currentTimeMillis();
    System.out.println("Count 1: " + count + " Time taken: " + (end - start));
}

public void count2(String text) {
    long start = System.currentTimeMillis();
    int count1 = text.length();
    text = text.replaceAll("\\w", "");
    long end = System.currentTimeMillis();
    System.out.println("Count 2: " + (count1 - text.length()) + " Time taken: " + (end - start));
}

public void count3(String text) {
    long start = System.currentTimeMillis();
    text = text.replaceAll("\\W", "");
    long end = System.currentTimeMillis();
    System.out.println("Count 3: " + text.length() + " Time taken: " + (end - start));
}

Countiung all alphanumeric characters in Sherlock.txt:
Count 1: 432188 Time taken: 269
Count 2: 432188 Time taken: 53
Count 3: 432188 Time taken: 22

tinyjavacode:

The new hardcore

25 Mar 2015

Trying some new hardcore - Assembly in Emacs 😁

Decorator pattern in Python

24 Mar 2015

Just found some interesting way of implementing Decorator design pattern in Python.

As Jason Smith said in his book (Elemental Design Patterns), “design patterns may be implemened in different ways in different programming languages”.

That’s said, design patterns are not some set of classes which will be implemented in a very similar way in different languages - they are just a way of doing something.

Thus, Decorator pattern is a way of wrapping some method’s or class’ behaviour. In Python it may be done with Context Managers:

from contextlib import contextmanager

@contextmanager
def tag(name):
    print "<%s>" % name,
    yield
    print "</%s>" % name,

with tag("h1"):
    print "moo",

print

with tag("div"):
    print "foo",

This code will end up wrapping print "foo" and print "moo" methods with printing some HTML tags around ‘em:

<h1>moo</h1>
<div>foo</div>

That is interesting as it implements Decorator design pattern in a bit hard-coded way, but using language features, not OOP ones.

Compare it to the "standard" OOP implementation in Python:

# -*-coding:utf-8 -*-
class SimpleText(object):
    def __init__(self, text):
        self.text = text

    def content(self):
        return self.text

    def __str__(self):
        return self.content()

class TagDecorator(SimpleText):
    def __init__(self, text, tag):
        super(TagDecorator, self).__init__(text)
        self.tag = tag

    def content(self):
        return '<{0}>{1}</{0}>'.format(self.tag, super(TagDecorator, self).content())

a = SimpleText('moo')
print('SimpleText: %s' % a)

b = TagDecorator('moo', 'h1')
print('TagDecorator (h1): %s' % b)