while waiting for build-install cycles to complete, I had the time to write 
this.

On August 8, 2011 09:15:37 am Harry van der Wolf wrote:
> = User friendliness (not mentioned before, but my point of view):

I can't read Kay's mind, but I think that user friendliness is one of the 
major motivator for his proposal.  Right now I am experiencing Hugin's 
*codebase* user unfriendliness.  I am trying to make small, superficial 
changes to the UI.  I change a couple of lines, then I have to trigger a whole 
cycle of compile and install before I can test.  Worse case such a cycle takes 
15-20 minutes on my machines.  Best case 5 minutes.  If the UI was Python, it 
would take a few seconds.  Not to speak about the time I waste in C++ because 
it is a very unfriendly language to code and requires coders to think of 
details that are solved almost automatically in Python.  I'll spare you the 
nitty gritty.  There is a huge time saving to be had by moving development to 
Python and you can only imagine what the "techies" can do for you once they 
can move forward faster with development.


> - All solutions offered so far come from the "techies" and relate to the
> code base, and off course they are the driving force behind the hugin
> community, but the techies are only 5% (maximum!) of the end-user base
> where both the windows end users (by far the biggest amount) and OSX
> end-users are (almost by definition) not the most technical users.

I do not want to go there.  No, really not.  A skyscraper has dozens of levels 
but only one basement.  Take the basement away and the skyscraper falls.  So 
much said.


> All solutions should aim for more user friendliness.

Kay's current proposal, from an end-user point of view, is STATUS QUO.  Not 
better not worse.  Simply unchanged.  It is user friendliness for the users of 
the codebase, i.e. the developers.

Eventually, with a streamlined codebase, the developers will be able to 
achieve more in less time and this will benefit end-users too.  But it is way, 
way, way, down the road.

In the first iteration best case we'll have the same functionality with a user 
interface that mimcs the exact user interface we have now.  Realistically 
speaking, it will be less.  Look at Ippei's GSoC 2007 project.  At the end he 
delivered a Qt app that had the assistant function.  That's it.  And it is 
enough work for a first iteration.

Programming the screen widgets (and the user interaction) is 80% of the work; 
and although I expect that that work will be much faster on the Python 
steroids, it is better to start small and stick to Kay's plan:  refactor the 
existing code base to make it more coder-friendly while keeping the exact 
functionality as it is, or even shedding some of it temporarily.

It's a two steps approach:  first make the codebase user-friendly to the 
coders; then let the coders make the app user-friendly to the end-
user.  It takes patience.  And the basement has to necessarily come before the 
penthouse.


> By now the python
> integration is certainly a help for new functionality but it's not user
> friendly.

It's only purpose by now is to attract scripters.  To scream out loud to the 
world: hey, I am here, script me!  If you can't script, there is not much 
for you here now but stay tuned.


> Also remember our discussions about how Hugin should look like.

Yes, remember it.  Keep it in the freezer for now.  When the new codebase 
replicates 80% of the current Hugin, it will be time to thaw it.  Once we're 
there, I estimate that it will take 10x less to implement the "how Hugin 
should look like" than now, because it will be implemented mostly in Pyton, 
not in C++.

 
> I'm not a coder of course but I don't think the code base is that bad,
> like mentioned by Tom Sharpless and the article mention by Habi.

The article mentioned by Habi does not talk code.  It refers to the user 
interface, and the statement I take from that article is that "Hugin is end-
user friendly enough".

I am not much of a coder either.  I am a part-time tinkerer, and in a few 
weeks I will be gone for a while anyway.  The learning curve of Hugin is very 
steep.  We've had this feedback since 2007 from most GSoC students that had to 
learn and get into it.  We can and should make that curve sweeter.


> When looking at first at the code, it is always tricky to find your way.

Disagree.  There is readable code and there is convoluted code.  And then 
there is mess.  Just simple things such as consistent indentation are an 
obstacle to get into the Hugin code.  We had a long cycle of adding feature 
after feature after feature for the end-user and it is time now to think of 
the coders and make their life easier.


> - Again: the techies know their way in the program as they are experienced,
> some with many, many years of experience. It still strikes me that so many
> users experience issues on "simple user-friendly" functionality (note:
> simple and user-friendly to the experienced users).

How about mirroring this argument? why should the techies do with unfriendly 
stuff and the end-users not?  IMHO the techies deserve a friendlier 
code-base at least as much as the users deserve friendlier functionalities, 
and ultimately friendlier functionalities depend from a friendlier code-base 
more than the other way around.

 
> = Going to a (in memory) database format:
> - Even though it seems a good step to make, it will create another
> dependency on all platforms. I don't like that.

New dependency have always been evaluated for benefits and draw backs.  Hugin 
does not scale well.  If somebody wants to make it scale well by adding such a 
database, they have all the right to do so.  If you don't like what they are 
doing... it is your right too but it is not your to stop them from doing so.


> - Do we implement our own sqlite3 "engine"  into the package or make it a
> system dependency which will certainly hinder a lot of end users.

why do you think that it will "certainly hinder a lot of end users"?  Do you 
use Firefox?  Has sqlite hindered you to?

http://www.sqlite.org/famous.html

> - What about the translations? It seems very logical to me to put them as
> well (or even as first) in a database.

absolutely not!  dynamic data goes into a database.  control points, image 
lists, etc.  translations are, from Hugin's perspective, static as a rock.  
leave them as they are.  they are not concerned.


> = (wx)Python:
> - Kay suggest to move to (wx)Python for logic and gui. Currently python is
> an issue on both windows and OSX. That doesn't mean that it can't have a
> glorious future but we are certainly not there yet. C(++) is a well defined
> standard. Python should definitely fully backward compatible to at least
> 2.6.

On what basis do you say that Python should be fully backward compatible to at 
least 2.6?  why not 2.4?  or 3.2?

Currently the python interface of Hugin is an issue on both Windows and OSX 
because it has not had the time to mature but there are plenty of cross-
plattform tools using wxPython or PyQt.

Try http://www.phatch.org/ to get a glimpse into a not too distant future, and 
please don't set compatibility requirements at this early stage.  We are 
talking a completely different application.  This is not Hugin.


> - When moving to (wx)Python: what will it do to performance?

This has already been discussed.  I hope the answer helped.


> A compiled binary is AFAIK much faster than any interpreted program.

With Python you can mesh up scripted/interpreted program and compiled binary.  
The canonical way of developing is to first script everything (unless you 
already have compilable code at hand, which is Kay's idea of copy&pasting from 
the existing codebase).  Then you identify where in the script are the 
bottlenecks and you rewrite those functions (and only those function) that are 
performance-critical.


> - To me the python extension (note my wording) is very good functionality
> to be able to build new functionality (by the experts) to be later on
> built (using C++) into Hugin for the greater, lesser skilled community
> (also related to end user friendliness).

sometimes you just don't need to rewrite it in C++ because Python does the job 
fast enough that you don't notice a difference.


> - We have some C(++) programmers on board. How many (wx)Python programmers
> do we have? This is a neccessity for continuity.

Actually at the moment we have nobody on board.  It's a matter of perspective.  
This is Open Source, everybody is free to come and go as they see please.  At 
the moment we have a complex codebase  that prevent many potential 
contributors from coming on board.  We've had this feedback consistently from 
many students since the first Google Summer of Code edition we participated 
to.

 
> = how? or why?
> - In previous mails we were already discussing "how to
> plan/structure/execute". To me this is how many projects (also within my
> own company) go off  the rails. The first questions are: Why do we want to
> do it? And actually who want's it: 95% end users struggling for the year
> to come or leaving, or 5% techies? What's the "business case"? Is it worth
> it? This is not some GSOC minor project (I don't mean this derogatory, not
> at all) which can be integrated at some point. It will make hugin shake
> (or break) at it's foundation.

This is no corporate environment and there is no need for a business case.  
It's a scratch your own itches environment.  If Kay has an itch, he will 
scratch it.  And if more than one person has an itch and want to team up, they 
will.  This is no place to argue for or against:  everybody is free to do what 
they want; and without meaning to be derogatory, it is no democracy either.  
It is not 95%.  It is not even 5%.  It is an individual choice for each and 
every person in the room.  What can I do and what do I want to do.  Kay 
definitely seems to want to go this way and I am with him.  For as much as my 
participation is worth.  In four weeks I will be reading only legal code and 
writing exams.

 
> I don't give much answers or solutions. Merely things to consider when
> doing such a major step which could break hugin easily for at least a year
> (or worse).

This won't break Hugin.  Not more than it is broken already.

This won't touch the Hugin default branch.  It will be a separate branch.  Or 
maybe it even makes sense to start a new repository, from scratch, and 
carefully cherry-pick / migrate by copy&paste desirable code while leaving the 
cruft behind.

Starting from scratch has a few advantages.

We could, for example, start to use Launchpad for the translations (this would 
put translations into a database ;-) sorry for the confusion, it's not sqlite, 
it is a "proper" way of databasing translations).  

We could use Git (and GitHub) instead of Mercurial (and SourceForge).

We could (don't jump at me, please) drop *in*the*short*term* the multi-
platform requirement and initially focus on achieving quick results for the 
one platform that we (team of people that decide to join Kay) choose as ours.   
If what we do is good, others will adopt and adapt it for their platforms as 
the project grows.

It's Open Source business as usual:  individual contributors decide on a case 
by case basis where and when they want to contribute their precious time and 
what they want to do with it.  Nobody can tell them what to do.  Within an 
established organization / project like Hugin, there are rules.  On the green 
field the only rule is:  you can join and influence or you can stay out and 
watch.  Given the choice, and if I have the time, I rather do the first.  I 
think Kay is on the right direction and I am willing to follow him with the 
little time I can dedicate to FLOSS at this moment.

Yuv

Attachment: signature.asc
Description: This is a digitally signed message part.

Reply via email to