sizeof(uint32t)

Using Boost Function with Qt, Part 2.

sohail@taggedtype.net (Sohail Somani) — Sat, 17 Oct 2009 14:09:00 +0000

please, please post that follow-up. I'm new to Qt and have just run into this problem. While searching the net, I think your solution seems like the best approach!

Who am I to deny a seeker of knowledge? Having used this method in a couple of projects now, I think it is fairly sound and easy to maintain. So here goes.
The main problem with the solution outlined in the earlier post was that it could not handle multiple arguments. On that same post, Ken posted his solution apparently inspired by mine. His solution also handles multiple arguments but does it by implementing qt_metacall, i.e., mimicking moc. This is probably the most scalable solution and I'll probably give it a second look when I need to do this again. The only problem might be requiring exact matches for types but I am not sure how much of an issue this is for code I have written.

To review, the problem is that we want to use function objects (Boost Bind, Boost Function, etc) as Qt slots because sometimes it is too much work to create stateful slots.

My solution looked something like this:


struct SignalHandler0 : QObject
{
private:
Q_OBJECT
public:
SignalHandler0(QObject * parent,
              boost::function const & f):
 QObject(parent), // parent will delete this object when destructed
 m_f(f) {}

public slots:
void
handleSignal()
{
 try
 {
   m_f();
 }
 catch(...)
 {
   // Cannot throw exceptions from signals.
   ASSERT_BUG_HERE
 }
}
private:
boost::function m_f;
};

bool
connect(QObject * sender, const char * signal,
     boost::function const & f)
{
return QObject::connect(sender,signal,
                       // Note: Not a leak as sender will delete the handler when destructed
                       new SignalHandler0(sender,f),SLOT(handleSignal()));
}

To extend it to a single argument, we might do:

struct SignalHandler1 : QObject
{
private:
Q_OBJECT
public:
SignalHandler1(QObject * parent,
              boost::function const & f):
 QObject(parent), // parent will delete this object when destructed
 m_f(f) {}

public slots:
void
handleSignal(QString const & a)
{
 try
 {
   m_f(a);
 }
 catch(...)
 {
   // Cannot throw exceptions from signals.
   ASSERT_BUG_HERE
 }
}
private:
boost::function m_f;
};

That is, create a new class with the right signature. So you might think: well that screams for class templates! Unfortunately, Qt does not support class templates. Doh.

So basically, we write it out:


struct SignalHandler : public QObject
{
template
SignalHandler(QObject * parent,boost::function f):
 QObject(parent),
 m_handler(new SignalHandlerImpl(f))
{}

struct SignalHandlerBase
{
 virtual ~SignalHandlerBase();
}

template 
struct SignalHandlerImpl
{
 SignalHandlerImpl(boost::function f):m_f(f){}
 boost::function f;
}
public slots:
void handleSignal(void);
void handleSignal(QString const &);
...

private:
shared_ptr m_handler;
};

void
SignalHandler::handleSignal(void)
{
typename SignalHandlerImpl type;
type* handler = dynamic_cast;(m_handler.get());
ASSERT(handler);
handler->f();
}

void
SignalHandler::handleSignal(QString const & a)
{
typename SignalHandlerImpl type;
type* handler = dynamic_cast(m_handler.get());
ASSERT(handler);
handler->f(a);
}

You can use macros to generate these handlers. You will also need overloaded connect() functions:

template
QObject*
connect(QObject * sender,
     const char * signal,
     boost::function slot);

...
template<>
QObject*
connect(QObject * sender,
                  const char * signal,
                  boost::function slot);

template<>
QObject*
connect(QObject * sender,
                            const char * signal,
                            boost::function slot);

Again, you can use macros.

I prefer Ken's solution from a technical standpoint. It is a good evolution. The main advantage of his solution is that the amount of code you need to add scales linearly with the number of arguments you need to handle whereas with my solution, they scale with the number of signals and that there are no macros.

The main advantage of my solution is that it is simpler to understand and maintain, which might be worth the extra code.

Hope that helps!

Hello, Toronto

sohail@taggedtype.net (Sohail Somani) — Sat, 12 Sep 2009 14:12:00 +0000

We just completed a cross-country move back to Toronto. Moving is tiring but my wife was very organized. I have to make it up to her somehow. We will still be setting up for a few months, I'm sure.

I'm looking for some good meet ups but I can't seem to find any quality ones. The only things I might actually be able to make time for are:

Backyard / amateur astronomy
Business-related
Software-related (anything to do with 3D graphics would be awesome)

I've found meet ups for the first 2 but nothing enticing for the software-related. It's all fluff.

The business-related one I will be attending is "Tech Entrepreneurs & Emerging Companies Group". There seem to be some serious people there. I look forward to sharing and learning (mostly learning, I'm sure!) from them. This one seems to be a diamond in the rough as most of the business-related meet ups are just advertising for the host.

Time will tell.

It's good to be back Toronto. By the way, your garbage bins have become too small.

The best market is one with lots of money

sohail@taggedtype.net (Sohail Somani) — Wed, 19 Aug 2009 05:04:00 +0000

There are always people who feel that developing plug-ins is not a profitable market. Now while developing a plug-in may not make you as rich as Bill Gates, if there is a sizable market, you will make money.

So if you are looking for whether your idea makes sense, here is a simple relation to figure it out:

UnitPrice * NumberOfQualifiedCustomers * ConversionRate >= SomeSpecificFinancialGoal

If the statement is true, you will make money. If it is not, you will fail.

I'm pretty sure that I grossly over estimated NumberOfQualifiedCustomers when creating Worklog Assistant. How did I over calculate? Simply, the number of total JIRA users who also use JIRA as a timesheet system is quite small (yeah, duh right?) I would not have known this if I did not reach market quickly.

However, I used very pessimistic values for ConversionRate so maybe that balanced it out because I still reached my financial goals.

What does this mean for me? It means V2 is going to kick some serious ass. Oh how I wish I could have people to work on this with me, wink wink :-)

Going AFK with Bazaar

sohail@taggedtype.net (Sohail Somani) — Thu, 09 Jul 2009 21:12:00 +0000

One thing I've really liked about distributed VC systems is that they handle merging really well. Of course, this is not limited to DVCSs. Subversion and Perforce have very good merging but do not support offline work very well.

I've been using Bazaar for a little while now for my app because I knew that I would need to be offline every now and then. I just had one of those periods and thought it would be a great chance to see how well AFK mode works with Bazaar.

This is more for my own future reference rather than for you :-)

laptop $ rsync -avz -e ssh sohail@desktop:/home/sohail/bzr/ ~/bzr
laptop $ bzr branch ~/bzr/code/master project
laptop $ bzr bind ~/bzr/code/master

Now I can work offline in the "project" directory and all checkins go to ~/bzr .

Upon return:

laptop $ rsync -avz -e ssh ~/bzr/ sohail@desktop:/home/sohail/bzr

NOTE TRAILING SLASH ON SOURCE DIRECTORY!!!!!1111oneone....

Note: I think the above is insane. Ideally, I'd just do something like:

laptop $ bzr checkout bzr+ssh://sohail@desktop/home/sohail/bzr bzr
laptop $ cd bzr
laptop $ bzr work-offline

Return from afk:

laptop $ bzr I'm back

Or something like that.

Software developer, businessman or problem solver?

sohail@taggedtype.net (Sohail Somani) — Sun, 28 Jun 2009 17:38:00 +0000

[Warning: Soap box post. I reserve the right to use this blog as such and you reserve the right not to read it! Please let me know if it reads like a Steve Yegge post. You can tell if it is like Steve Yegge if you hate it more and more as you read it. If this is so, please inform me and I will revise the article.]

As a software developer and still fledgling businessman, I am faced with many problems I need to solve each day. From how to accept payments online to maintenance renewals to how to write as little code as possible to do something useful, sometimes it boggles the mind how much we really have to deal with each day in our profession. Good thing I don't think about it much!

Some time back, I had lunch with a friend and we got to talking about needed skills for a software developer. This friend is quite possibly one of the smartest guys I know, not because he knows at what point Newton's theories break down or how generational garbage collection works, but because I think he really understands people. So I was very interested when he stated that the most important skill needed is the ability to search out solutions to problems. Not coding or encyclopedic knowledge of C++, .NET, Java, or functional programming but simply, the ability to take a problem, go away and come back with a solution.

I don't recall whether we talked about it more but it's been sitting in the back of my mind. Ever since then, I've come across situations where this statement jumps to the forefront and I think, "Yeah, this person could be a really good problem solver!" or "Hmm, I really should have tried to put on my problem solving hat here."

Is software development or growing a business actually problem solving? Maybe the answer is obvious to you but I have never thought about it consciously. To answer that question, I have to think about what a problem is. To me, a problem is an obstacle in the way to achieving a goal.

A goal one should probably have when starting a software business is to get paid. Now, unless I am experienced at achieving this goal, I will have no idea where to start. So one of two things will happen:

I will give up because I don't know the answer already
I will start to look for the answer

I know, it's obvious right? Every time there is a bug I don't know how to fix, or a feature I don't know how to implement, I am faced with these two choices. I'd like to think that I never choose the first option, but I'd be lying to myself.

Fixing bugs is something I'm generally good at. I've fixed some whoppers (mmm whopper) in the past, self-inflicted or otherwise. So I rather like the example above of choosing a way to get paid because I've never done it before. I've no idea how it works. I'm deathly afraid to screw up. But I've bought lots of software online. I know people who sell software online. So I start by asking people I know or people I trust. I recall situations in which I hated the purchasing process and situations in which it was the best process ever. I go back to these online stores and find out what I liked or hated. I make a list and check it twice.

With all this research, I have not written a line of code, yet I now have a very good idea of what a good solution should look like. Problem solved? Not quite. Now I have to decide whether to buy or build. I've already decided ahead of time that writing it myself is not really something I'm interested in but to ensure I understand what is going on, I research this topic as well. Indeed, it is not worth it. Eventually, I settle on a reseller and move on to achieving the next goal.

There is nothing magical about solving the problem above. In fact, it is almost mechanical. But the key point is the decision that was taken at the first point. That is, the decision to actually solve the problem.

I am fairly convinced that software development as well as growing a fledgling business are very much problem-centric. They are filled with goals along with many obstacles to achieving them. At each obstacle, you have two choices: to give up or keep going. We need to keep going. This does not mean being stubborn and trying the same thing over and over again. This often means trial and error, hypothesizing and experimentation (Carl Sagan might like that!) Above all, don't give up and say it is impossible.

Anyway, just thought I'd put the thought in your heads since it's been in mine for a while. I think I'm going to try calling myself Chief Problem Solver from now on.

VanCPP June meeting

sohail@taggedtype.net (Sohail Somani) — Mon, 08 Jun 2009 23:37:00 +0000

If you are in Vancouver and interested in programming (who isn't?!) you might want to make your way to the VanCPP meeting in June. The announcement is below:

Our June 2009 meeting will be held on Thursday, June 18. Please note the new venue.

Topic: Concurrent Programming in the D Programming Language

Presented by Walter Bright

Abstract: Many-core concurrent programming offers exciting and compelling advantages. The single core, single thread programming model is assumed by imperative programming languages. This model offers sequential consistency as its fundamental characteristic.Because many-core systems use layered cache memory systems,sequential consistency is not guaranteed among threads.Because imperative programming languages allow implicit sharing of data between threads, many misguided idioms and optimizations are possible that erroneously assume sequential consistency.One example of this is the double checked locking optimization.The pernicious nature of these sorts of bugs is they defy programmers' natural intuition about how programs behave,they are not statically detectable, and there is no way to reliably test a program to rule out the existence of such bugs.A program may appear to work, but have problems appear years later, fail when ported to a different platform, and such problems may be extremely hard to reproduce and track down.In essence, the correctness of the program relies entirely on the expertise and care of the programmer.This is not an acceptable situation for developers of programs that require high reliability.

The D programming language is an imperative programming language with an innovative type system that prevents implicit sharing and also fosters a complete, integrated pure functional subset. It is possible to statically verify that D programs do not have sequential consistency bugs. The double checked locking optimization bug is not possible. Type support for shared data and immutable data, as well as pure functions, means that mutating data interactions between threads can occur only under carefully controlled conditions.This dramatically reduces the problem space for concurrency bugs from the whole of the source code to a small subset of it, making it a much more tractable problem.

Speaker bio: Walter Bright graduated from Caltech in 1979 with a degree in mechanical engineering. He worked for Boeing for three years on the development of the 757 stabilizer trim system. He then switched to writing software, in particular compilers, and has been writing them ever since.

The meeting will be held at:
Workspace
21 Water Street
Vancouver, BC
V6B 1A

Regards,

Vladan Vidakovic

Using C++0x lambda to replace Boost Bind in C++03 code

sohail@taggedtype.net (Sohail Somani) — Fri, 08 May 2009 01:26:00 +0000

[Note: This post looks ugly under Internet Explorer. If you want to tell me how to fix my CSS, that would be much appreciated]
[Note: This post was written using the Intel C++ compiler with -std=c++0x.]

As some of you know, I work on Worklog Assistant which is written using C++/Qt.

One thing that I've made very good use of is a slightly modified version of the code in an earlier post titled "Using Boost Bind and Boost Function with Qt".

As an example, consider the following code from the above app which creates a popup menu to toggle the visibility of table columns. This is done by creating a "toggle" action for each column header that... toggles the visibility. It might help to think how this action would be created in plain Qt (hint: it would be painful.) It would certainly not have the locality it does now.

void
showColumnHeaderContextMenu(ssci::CustomTableView * self,const QPoint & pos)
{
QMenu columns(ssci::CustomTableView::tr("Visible Columns"));
columns.setIcon(QIcon(QString::fromLatin1(":/ui/icons/grid.png")));

QHeaderView * headers(self->horizontalHeader());

std::vector<std::pair<QString,int> > sorted_columns;
getSortedColumns(self->model(),headers,sorted_columns);

for(int ii = 0; ii < headers->count(); ++ii)
{
QAction * action =
 new QAction(sorted_columns[ii].first,
             &columns);

bool is_hidden = headers->isSectionHidden(sorted_columns[ii].second);

action->setCheckable(true);
action->setChecked(!is_hidden);

using boost::bind;
using boost::function;

function<void()> toggle =
 bind(&QHeaderView::setSectionHidden,headers,
      sorted_columns[ii].second,!is_hidden);

ssci::connect(action,SIGNAL(triggered()),
             toggle);

columns.addAction(action);
}

QMenu menu;
menu.addMenu(&columns);

menu.exec(self->mapToGlobal(pos));
}

Of particular interest is the code in the for loop which sets up the actions:

    function<void()> toggle =
 bind(&QHeaderView::setSectionHidden,headers,
      sorted_columns[ii].second,!is_hidden);

 ssci::connect(action,SIGNAL(triggered()),
               toggle);

This creates a function object on the fly which hides the selected column using code from the above linked post. To do this in plain Qt is a gigantic pain. LibQxt has a solution as well but mine is much better!

Anyway, the point is that you might find a lot of code using bind and function in an app like this. Binding member function pointers, member data pointers and function pointers is fairly normal and is really the only way to maintain sanity and reduce boiler plate. Nested binds are also used where appropriate.

Boost Bind is a way to create closures, or at least as close as you can get in C++ to true closures. Therefore it is natural to try and replace some uses of Boost Bind with C++0x lambda. There is good coverage of how C++0x lambda works here so I won't repeat the same information. However, I will cover the cases of bind I could convert and (horrifically) the cases I couldn't!

Using automatic variables

Consider the following code:

const int LICENSING_TAB_INDEX = 1;

ssci::connect(lblImportNewLicense,SIGNAL(linkActivated(QString const &)),
             boost::function<void()>(
               boost::bind(&QTabWidget::setCurrentIndex,
                           tabWidget,
                           LICENSING_TAB_INDEX)
               )
 );

The above function call sets things up so that when a link is clicked in the interface, the LICENSING_TAB_INDEX tab is selected in the configuration.

One thing Boost Bind does is that it stores all bound arguments by value. That means &QTabWidget::setCurrentIndex, tabWidget and LICENSING_TAB_INDEX are all stored by value. C++0x lambda calls this capturing. This can be done using implicit capture (by parsing the lambda body) or by you. By default, C++0x lambda captures variables by reference. It is potentially buggy to capture function-local variables by reference automatically. Therefore, the above code translated to C++0x lambda is:

[=]()
{ tabWidget->setCurrentIndex(LICENSING_TAB_INDEX); }

The first element of a lambda-introducer (the []) can be a capture default which can be one of = or &. The capture default tells the compiler how to capture those variables that are implicitly captured. The assignment is supposed to make you think of copy assignment and the & is supposed to make you think of reference to. So in the above case, to get the exact same behaviour as the bind, we need to intentionally copy all variables by value.

Great! Not so bad :-)

A simpler example... Or is it?

Consider the following code:

ssci::connect(clearSelectedRole,SIGNAL(clicked()),
             boost::function<void()>(
               boost::bind(
                 &QComboBox::setCurrentIndex,
                 projectRoles,
                 -1)
               )
 );

This code sets things up so that when the clearSelectedRole button is clicked, the corresponding QComboBox has an invalid index.

The C++0x version of this is really straightforward:

ssci::connect(clearSelectedRole,SIGNAL(clicked()),
             boost::function<void()>(
               [&](){projectRoles->setCurrentIndex(-1);}
               )
 );

In this case, the pointer object (not the value) projectRoles is captured by reference. This is not an issue because the pointer object is guaranteed to outlive the closure. Now you know why closures and garbage collection go together :-)

Verbosity or Why I wish C++0x used polymorphic lambdas

Consider the following code:

static
void
updateThreadSetup(QObject * parent,ssci::MainWindow * self);

m_checkForUpdatesThread(boost::bind(updateThreadSetup,_1,&parent))

The bound function in this case is an object that calls the function updateThreadSetup with a to-be-determined value for the first parameter and a fixed value for the second parameter.

The C++0x version of this is horrible:

m_checkForUpdatesThread([&parent](QObject * obj){updateThreadSetup(obj,&parent);});

First, since parent is a local variable (was passed into the function), you can't implicitly capture it. So you have to explicitly capture it. In this case, we want to capture it by reference, hence [&parent] in the lambda-introducer. Then, since this thread setup function is passed in a QObject* we have to tell the compiler to accept this argument. Apparently it isn't smart enough. Ask someone why it is this way, you'll hear some hand waving about the callable concept. Whatever.

That is some ugly code.

Anyway...

What you cannot convert without making your code super ugly

Consider the following simple code:

vector<int> d = {1,2,3,4,5};
vector<function<int()>> funcs;

for(vector<int>::iterator it = d.begin(), end = d.end();
   it != end;
   ++it)
{
 funcs.push_back(boost::bind(add5,*it));
}

This creates a vector of function objects that presumably add 5 to their bound argument and return the result.

Here is the equivalent in C++0x lambda:

vector<int> d = {1,2,3,4,5};
vector<function<int()>> funcs;

for(vector<int>::iterator it = d.begin(), end = d.end();
   it != end;
   ++it)
{
 int &i = *it; // WTF?
  funcs.push_back([i](){add5(i);});//THIS IS REDUNDANT. REDUNDANT.
}

Naively, one might have done:

funcs.push_back([it](){add5(*it);});

in the loop. But this is a bug waiting to happen. Add the following line right after the for loop:

d.push_back(0)

Now all those iterators that are captured by value can be invalidated! YAY! The only way to avoid this issue is to manually extract the value referenced by the iterator and pass that into the closure which is what I did in my translation.

Conclusion

This exercise showed me that C++0x lambda is of some interest to me. I'd really like to get rid of the verbosity (I know, too late!) A couple of things would make this the perfect lambda for me:

Polymorphic lambdas (or at least let me specify auto for the arguments)

An easy way to capture computed values (the *it bug above)

I don't know how these problems would be solved, or whether they could be but until they are, I think there is still a future for function binding ala Boost Bind which is fine by me!

BoostCon 2009

sohail@taggedtype.net (Sohail Somani) — Mon, 04 May 2009 04:23:00 +0000

BoostCon starts tomorrow.

I went to the first and second Boost conferences. The first as an attendee, the second as a speaker. I was blown away by the quality of the talks, particularly the author's corner series of talks. I think that if the organizers are smart about it, this can be one of the best conferences. For me, it is already on par with conferences like SD West for quality and relevance.

I am extremely disappointed that I could not make it this year due to my schedule being way too busy. I hope that some of you reading this have been able to schedule better than me and go to BoostCon.

If you are attending, please ask at least one very difficult on-topic question in each of your talks for me.

Also, ask Joel de Guzman about Boost.GUI. Apparently he's got something cooking (you didn't hear it from me!)

A seemingly complete Qt API for CL

sohail@taggedtype.net (Sohail Somani) — Thu, 19 Mar 2009 22:51:00 +0000

Just came across this library called CommonQT.

It is more complete than the API I developed earlier. It is also using the KDE Smoke libraries which make it damn easy to create the API on the fly.

Very exciting.

Latest NVIDIA drivers, Ubuntu Edgy

sohail@taggedtype.net (Sohail Somani) — Sun, 15 Feb 2009 22:01:00 +0000

NVIDIA drivers not loading after the latest Ubuntu update? Low resolution mode?

They used to work didn't they?

Before you start uninstalling Ubuntu packages and installing the official NVIDIA drivers, throwing your hands up and generally having a bad day, try this:

(as root): echo nvidia >> /etc/modules

Reboot. Should work now.

For some reason, you need to explicitly load the module with the latest nvidia packages (I'm using nvidia-glx-new)

Qt goes LGPL!

sohail@taggedtype.net (Sohail Somani) — Wed, 14 Jan 2009 08:51:00 +0000

http://www.qtsoftware.com/about/news/lgpl-license-option-added-to-qt

Now that's awesome.

Using Boost Bind and Boost Function with Qt

sohail@taggedtype.net (Sohail Somani) — Wed, 26 Nov 2008 19:03:00 +0000

One very, very, very annoying feature of Qt in C++ is how very difficult it is to create bespoke slots.

With gtkmm, you can more or less get away with using boost::bind so long as the bind results in a 0-ary function (otherwise the signal/slots library for gtkmm is not compatible.)

With Qt, you have to write a new member function, or heaven forbid, a new class. This is too much typing for me. Ideally, what I would like to do is something like:


connect(some_button,SIGNAL(clicked()),
        boost::bind(&Foo::bar,something,else,entirely));

Doing this with bare Qt, I'd have to:

Create a new slot function: Foo::bar_special_case

Add member variables for the variables else,entirely

Finally use it as: connect(some_button,SIGNAL(clicked(),something,SLOT(bar_special_case()))

After doing this for the 100 billionth time, I realized that there should be a better way to do this. After months of investigation, I have discovered that there is no better way to do this.

Just kidding.

The idea is to create a slot handler that accepts boost::function types:


struct SignalHandler0 : QObject
{
private:
  Q_OBJECT
public:
  SignalHandler0(QObject * parent,
                 boost::function<void(void)> const & f):
    QObject(parent), // parent will delete this object when destructed
    m_f(f) {}

public slots:
  void
  handleSignal()
  {
    try
    { 
      m_f();
    }
    catch(...)
    {
      // Cannot throw exceptions from signals.
      ASSERT_BUG_HERE
    }
  }
private:
  boost::function<void(void)> m_f;
};

If I were to use this class directly, I would write:


connect(button,SIGNAL(clicked()),
        // Note: Not a leak as button will delete the handler when destructed
        new SignalHandler0(button,boost::bind(&Foo::bar,something,else,entirely)),
        SLOT(handleSignal()));

That's pretty much it. Of course, this is a bit too verbose so I'd write a free function:


bool
connect(QObject * sender, const char * signal,
        boost::function const & f)
{
  return QObject::connect(sender,signal,
                          // Note: Not a leak as sender will delete the handler when destructed
                          new SignalHandler0(sender,f),SLOT(handleSignal()));
}

And use it as:::connect(button,SLOT(clicked()),boost::bind(&Foo::bar,something,else,entirely))

The obvious problem with this approach is if you add any overload of the free function + bind and you are in for some fun. I prototyped a solution for this based on the Boost.FunctionTypes library but at the moment, I don't need this (i.e., I am happy with 0-ary bind)

Another thing... Why does the aforementioned function types library not handle boost function and boost bind?

Odd.

PS: I'm not dead. I just smell funny.
PPS: Sorry for so long in between posts, I've been very busy (the good kind!)

Everything you ever wanted to know about tr1::function but were too afraid to actually know

sohail@taggedtype.net (Sohail Somani) — Sun, 05 Oct 2008 19:17:00 +0000

Working title for a talk I'm giving October 16 at the Vancouver C++ Users Group.

I find three patterns of usage around Boost Function/Bind:

The right way

The wrong way

Running away

My goal for this talk: attendees should no longer be in the dark about how Boost Function/Bind (and by extension, tr1 function/bind) work. If you are reading this blog, coming to this talk, not the author of this post and you have some things you'd like to hear covered, please feel free to leave some comments. I'm pretty sure the intersection of all those groups of people is the empty set but it never hurts to ask!

Heckling must be reserved for the end.

PS: Regular posting will resume some point soon!

Qt/Lisp: more progress

sohail@taggedtype.net (Sohail Somani) — Thu, 31 Jul 2008 15:06:00 +0000

I've replaced the unsightly (make-instance 'qstring :ch "Foo") with a reader macro: #q"Foo". Ideally we'd use cl:string and qstring interchangeably but right now its too much of a PITA to make that work.

I've also made it possible to use closures for slots (see example below.) Frickin sweet.

Anyway, I started getting into the Dock Widgets example but lost interest after seeing all the code. Here is the code so far. Not very concise yet but will get there. Once I get into make-it-less-ugly mode, I will probably copy what Paul did with EQL as he calls it now.

~~Also the :foreign-pointer thingy will go away when I get around to adding cffi type translations.~~

svn-bisect

sohail@taggedtype.net (Sohail Somani) — Mon, 28 Jul 2008 23:04:00 +0000

Well it was only a matter of time... svn-bisect.py lives!

Greg Noel of SCons fame (is that really fame?) has committed a modification of a script I created whose purpose was to binary search the introduction of a bug in a SVN repository.

Example usage of the script is here.

Enjoy.

Why complaining works..

sohail@taggedtype.net (Sohail Somani) — Mon, 28 Jul 2008 22:51:00 +0000

My email to an online store:

Hey guys, I ordered product XYZ from your site yesterday. According to your shipping estimates, it should be here in 2-4 days. However, I see that it is not shipped yet. I have had one bad experience with your service before and would not like it to repeat. Please see that this is so.

Literally 5 minutes later:

Your order has been shipped.

Now if I can only get them to do it before I complain.

Simple CFFI - Qt4 integration attempt

sohail@taggedtype.net (Sohail Somani) — Tue, 22 Jul 2008 17:04:00 +0000

Update: Paul has sent me his code. He calls it "EQL" for ECL and Qt. Or something like that anyway! I have put it up here.

The author of the Simple CFFI - Qt4 integration attempt has contacted me to let me know that a modification of the above linked software is in commercial use. I have prodded him to release his modified version. He says he'll do it Real Soon Now (TM).

I don't know if he is reading this blog but maybe a little pressure will help. Just kidding!

What I like most about his method is the use of the introspection capabilities of Qt. Compared to the duct tape and glue I used, his is a lot more elegant. Currently, you cannot extend Qt in Lisp (via inheritance) but all the other goodies are still there. Indeed he tells me that for his application, he extended Qt from within C++ and used these extensions from his Lisp.

I look forward to the update and to using the library.

Qt/Lisp: looking for feedback

sohail@taggedtype.net (Sohail Somani) — Fri, 18 Jul 2008 17:22:00 +0000

Update: You can download the generated code from here.

The tubes were down this morning, so I managed to get up to tutorial 6 in my Qt/Lisp API. It covers about 95% of the API by design so most of the non-extension tutorials/examples should work.

Tutorial 1:

Tutorial 2

Tutorial 3

Tutorial 4

Tutorial 5

Tutorial 6

I would like to hear your complaints, suggestions, feedback if you have any.

Note that this API is a first draft and I thought it better to have something out there than wait until everything is perfect.

To start with, my current complaints:

(in-package :qt) -> Nothing is actually exported from the package yet :-)

~~(make-instance 'qstring ...) -> A really verbose way to pass a string! Should convert lisp strings to qstrings automagically.~~

Naming: instead of qpush-button, q:push-button

No way to extend Qt from within Lisp yet (tutorial 7 won't work)

~~No way to attach arbitrary functions as slots~~

Not Lispy enough.

I expect to address most of these at some point though the "Not Lispy enough" complaint is a bit subjective.

Sohail, it doesn't work anymore

sohail@taggedtype.net (Sohail Somani) — Wed, 09 Jul 2008 16:56:00 +0000

Everyone has a story about when they were younger. For example, Joel Spolsky talks about his time in an army bakery (or something like that.) Sometimes, the stories are quite pathetic like Al Bundy and his high school football team. I am neither as exciting as Spolsky, nor as pathetic as Al Bundy (though I'm sure the latter is up for debate.)

This story is about something that happened to me when I was younger that made me who I am today.

I started programming quite late by geek standards. I was either 11 or 14 depending on whether you count batch files as programming. But I loved it. And when I got tired of programming, I'd program some more in FastTracker 2!

For a while, I had a job as a pharmacist's assistant. This particular pharmacy had the option for delivery of prescriptions and other general items. The deliveries were done in the evening and were done by two very friendly guys named Krish and Sam.

Part of my job here (besides preparing the methadone!) was to add up all the deliveries that these two guys did within some period of time and summarize for the boss. It used to take me hours in a busy month as it required use of some large Excel spreadsheet. So I resolved to solve that problem with my programming chops. I got the owner to agree to pay me hourly (wow, $10/hour!) and he told me not to spend "too much time" on it. So I guesstimated 40 hours until I would be able to deploy the application. He was fine with that.

I was mostly right but near the end of it, while I was testing with the users (me), it turned out some other data collection was necessary. After discussing with the boss, he said it was important but not to spend "too much time" on it. By then, I had come to realize that "too much time" means "don't charge me more than I want to pay you." So I added it quickly, and it was done.

I deployed the application in December of that year to rave reviews from the boss. I'm not sure if the other employees cared that much but I know that it made my life easier and the count of deliveries more accurate so I was happy.

Due to other responsibilities (I think it was school?), I had to reduce my hours at the pharmacy. That was around June. I had trained the other people to use the application and it was becoming quite necessary for them to use if they wanted to retain their sanity.

Fast-forward to November. I get a call. "Sohail, it's not working anymore." "Crap", I thought. What did I miss? I went into the pharmacy and fudged around in the flat files to see what could be wrong.

It turns out that one of the data files was being named incorrectly. Can you guess which data file? Yes, it was the one I had added last just before I completed the project.

I think I spent about 10 unpaid hours debugging the problem at home while studying for exams/finishing projects. It came down to this (in C++, I don't really recall the language):


// data1.cpp
const char * months[] = {"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};


// data2.cpp
const char * months[] = {"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov ","Dec"};

Can you see the problem? In the second instance, I added a space after "Nov". So while data2.cpp was saving "Data2Nov Year.file", data1.cpp was saving "Data1NovYear.file" and the code that summarized the data was trying to open "Data<N>NovYear.file".

Oops.

I fixed this bug and apologized to the owner. I explained why it happened and that I fixed the code duplication. The boss said that he thought I should get an award for this software (a big ego boost!) and wondered if he could sell it to other people. Apparently he had been raving about it to his other pharmacist buddies. I don't remember what I said to him about that (something about me not having enough time to modify it to be generic enough as Sam and Krish were hardcoded!) but I really learned something that month.

Fortunately, in this case, things turned out alright. So I swore to avoid similar problems in the future in case future clients were not as forgiving. How did I do this? Quite simply:

Thorough testing

No copy-and-waste

My business cards have always had some variation of this. The current incarnation has something like "Do it once, do it right." Corny, but conveys my philosophy quite well. I will work very hard to reduce code duplication now. I try my best to write a test for each function/class that I write. Yes it is hard work. Yes it takes time. Quite frankly, software is hard. But in the end, I get very few calls saying "Sohail, it doesn't work anymore."

And no, you are not allowed to put a comment on this post saying "Sohail, it doesn't work anymore" :-)

Automatically rescale a Gtk::Image (and preserve aspect ratio)

sohail@taggedtype.net (Sohail Somani) — Tue, 24 Jun 2008 04:32:00 +0000

Don't really have enough time to explain it all, but hopefully the comments help. Here are a couple of screenshots:

The image used in the examples above is here.

And the code:


/*
  Problem:

  Using GTK, display an image in a window and rescale when the window
  resizes preserving the aspect ratio.
  
  Analysis:

  Gtk provides Gtk::Image which works on a Gdk::Pixbuf (pixel buffer)
  which allows rescaling but without preserving aspect ratio.

  Summary of solution:

  Use a Gtk::Image embedded in a Gtk::AspectFrame and resize image
  using dimensions determined by Gtk::AspectFrame. The AspectFrame
  knows how to maintain a ratio so it does the messy work for us.

 */

#include <gtkmm.h>
#include <iostream>

/// This Widget only scales the image but does not preserve
/// aspect ratios.
struct ScalingImage : public Gtk::Image
{
  explicit
  ScalingImage(Glib::RefPtr<Gdk::Pixbuf> pixbuf,
               Gdk::InterpType interp = Gdk::INTERP_BILINEAR):
    Gtk::Image(pixbuf),
    m_original(pixbuf),
    m_interp(interp),
    m_sized(false)
  {
  }

protected:
  virtual
  void
  on_size_allocate(Gtk::Allocation & r)
  {
    // This event is fired on all Widgets when their rectangle gets
    // resized. So we rescale our image. But rescaling our image fires
    // another resize event, and another, and another... You see the
    // problem!
    //
    // The most straightforward solution is to not rescale the image
    // the second time the event is fired. Hence the m_size toggle.
    //
    // Ideally I'd not like to do this but this was the best way I
    // found!
    if(!m_sized)
    {
      Glib::RefPtr<Gdk::Pixbuf> scaled = 
        m_original->scale_simple(r.get_width(),
                                 r.get_height(),
                                 m_interp);
      // Reset the image to be the new scaled image which
      // will cause the second size-allocate signal
      Gtk::Image::set(scaled);

      // Make sure we don't treat it as a rescale request 
      // next time
      m_sized = true;
    }
    else
    {
      // Reaction to set above. Call the base class's on_size_allocate
      // function. Shouldn't I have to call this above too? Maybe it
      // isn't necessary since it gets called anyway.
      Gtk::Image::on_size_allocate(r);

      // Treat next resize event as a rescale
      m_sized = false;
    }
  }
  
private:
  Glib::RefPtr<Gdk::Pixbuf> m_original;
  Gdk::InterpType m_interp;
  bool m_sized;
};

/// This widget automatically scales the image but preserves the
/// aspect ratio of the original image. This is accomplished via use
/// of the AspectFrame class
///
/// Ideally would like this to be a Gtk::Image subclass.
struct AspectPreservingScalingImage : public Gtk::AspectFrame
{
  explicit
  AspectPreservingScalingImage(Glib::RefPtr<Gdk::Pixbuf> const & pixbuf,
                               Gdk::InterpType interp = Gdk::INTERP_BILINEAR):
    m_img(pixbuf,interp)
  {
    set(Gtk::ALIGN_CENTER, Gtk::ALIGN_CENTER,
        // Aspect ratio of frame
        pixbuf->get_width()/float(pixbuf->get_height()));
    // This makes it appear as if there is no frame
    set_shadow_type(Gtk::SHADOW_NONE);
    // This allows a minimum size
    set_size_request(pixbuf->get_width()/2,pixbuf->get_height()/2);
    // Finally, add the image to be managed
    add(m_img);
  }
private:
  ScalingImage m_img;  
};

int main(int argc, char* argv[])
{
  if(argc != 2)
  {
    std::cout << "Usage: " << argv[0] << " <image-file>" << std::endl;
    return 1;
  }

  Gtk::Main kit(argc,argv);

  Gtk::Window win;
  Gtk::VBox box;
  win.add(box);

  Gtk::LinkButton lb("http://www.utahskies.org/image_library/deepsky/constellations/orionwa.jpg");
  AspectPreservingScalingImage apsi(Gdk::Pixbuf::create_from_file(argv[1]));

  box.pack_start(lb,Gtk::PACK_SHRINK);
  box.pack_start(apsi);
  
  struct launch_browser
  {
    static
    void
    doit(Glib::ustring const & addr)
    {
      std::string command("firefox ");
      command += addr.c_str();
      std::system(command.c_str());
    }
  };

  lb.signal_clicked().connect
    ( 
     sigc::bind(
                sigc::ptr_fun(launch_browser::doit),
                lb.get_uri()
                )
      );
      

  win.show_all();

  Gtk::Main::run(win);
}

C++ Standard GUI

sohail@taggedtype.net (Sohail Somani) — Thu, 05 Jun 2008 17:19:00 +0000


#include <gtkmm.h>

namespace std
{
  namespace gui = Gtk;
}

I love gtkmm.

Linux printing: Brother MFC-465CN

sohail@taggedtype.net (Sohail Somani) — Mon, 02 Jun 2008 20:18:00 +0000

I've been using Linux for a long time and as has anyone who has done so, printers, scanners and basically anything else that does not have a USB storage interface is a risky proposition.

Not so with the Brother MFC-465CN.

My setup process (on Ubuntu Hardy/8.04):

Set up hardware as suggested in manual

Skip software installation and connect printer to network via ethernet

sudo apt-get install brother-lpr-drivers-extra brother-cups-wrapper-extra

System->Administration->Printing->Test page

sudo apt-get install xsane sane

Get brsane2 driver (read the instructions!)

Launch xsane and test scanner

I don't even want to remember what it used to be LIKE before. Brother has GPLed their printer driver which is probably part of the reason it was so easy to set up. Great job Brother and many thanks to the Open Source fairy.

YUI and Parenscript

sohail@taggedtype.net (Sohail Somani) — Thu, 29 May 2008 05:18:00 +0000

Parenscript is a nice little mini-language that lets you compile Lisp to JavaScript. Sort of like Google does with GWT and the language to end all languages: Java.

Parenscript code looks like this:


(ps:ps
  (defun say-hi ()
    (alert "Hi!"))
  (say-hi))

The macro ps:ps compiles the Lisp code to a JS string which looks like this:


function sayHi() {
    alert('Hi!');
};
sayHi();

Notice the conversion from say-hi to sayHi. I love the Common Lisp naming conventions. They make so much sense and I miss them everywhere else. Obviously the writers of Parenscript agreed with me so they convert each symbol they see into a JS symbol which keeps things looking mostly neat.

The major conventions are (I don't know that there are more):

*foo* becomes FOO

foo-bar becomes fooBar

foo.*bar becomes foo.Bar

Anyhoo, YUI is a largish but nice JavaScript library that one can use for creating quite interactive web applications.

The problem is that YUI has names like YAHOO.util.Event.onDOMReady which is a handful to type even in JavaScript. If you try converting this symbol via ParenScript you will be in for a surprise (try it!) Anyway, there are a couple of ways to write this in ParenScript and keep the casing intact without losing your hair:

*yahoo*.util.*event.on-d-o-m-ready

|:YAHOO.util.:Event.:onDOMReady|

This works because the bars prevent the reader from downcasing or upcasing the symbol and ParenScript promises that it will leave symbols that begin with a colon alone.

Even so, this is still a PITA to type. What I do is I have a wrapper script that gets compiled once with short names for all of these. So for the above example, using Hunchentoot:


(defin-easy-handler (my-yui :uri "/ps/my-yui.ps") ()
  (ps:ps
    (defun yui-on-dom-ready (fn) 
      (|:YAHOO.util.:Event.:onDOMReady| fn))
    (defvar yui-some-other-funky-name |:YAHOO.util.:FunkyChickens|)))

Yay.

30 day product challenge: update

sohail@taggedtype.net (Sohail Somani) — Mon, 26 May 2008 19:14:00 +0000

The idea: Develop or prototype a commercial application in 30 days. Then decide what to do with it.

Initially I had thought this Wiki would be the central point for a uISV community but I should have known better. It appears that people are a lot more comfortable with using their own blogs to update progress.

With that in mind, Patrick McKenzie (a successful uISV owner, whom I greatly respect) has decided to jump on the bandwagon in his own way

I am joining up with him and will be starting in mid-June while I complete some other work.

I will be aggregating all the 30 day participants I can find at this feed

Best of luck and happy coding!

Very cool interview with a compiler developer

sohail@taggedtype.net (Sohail Somani) — Fri, 23 May 2008 05:44:00 +0000

Its sad that this is interesting for me but when you are waiting for a large C++ project to compile (gtkmm), you listen to these things in the background:

The route to C++ code optimization

The C++ compiler is the best MS product that exists. Well the only good product... Or maybe I just have a soft spot for C++ compiler developers. Either way, this man (also) uses Emacs (the illegal version) so maybe there is more to the story.

Channel 9 people: You need to have a whole series on the C++ compiler from top to bottom.