Email Archive: gallery-devel (read-only)

2001:
Jan
   
Feb
   
Mar
   
Apr
   
May
   
Jun
   
Jul
   
Aug
   
Sep
   
Oct
   
Nov
(123)
Dec
(21)
2002:
Jan
(62)
Feb
(105)
Mar
(85)
Apr
(126)
May
(142)
Jun
(35)
Jul
(140)
Aug
(76)
Sep
(163)
Oct
(62)
Nov
(90)
Dec
(37)
2003:
Jan
(115)
Feb
(99)
Mar
(80)
Apr
(55)
May
(88)
Jun
(12)
Jul
(17)
Aug
(28)
Sep
(47)
Oct
(37)
Nov
(65)
Dec
(30)
2004:
Jan
(31)
Feb
(82)
Mar
(59)
Apr
(34)
May
(34)
Jun
(55)
Jul
(25)
Aug
(55)
Sep
(36)
Oct
(27)
Nov
(59)
Dec
(28)
2005:
Jan
(44)
Feb
(46)
Mar
(33)
Apr
(63)
May
(38)
Jun
(63)
Jul
(128)
Aug
(115)
Sep
(88)
Oct
(51)
Nov
(49)
Dec
(63)
2006:
Jan
(51)
Feb
(99)
Mar
(68)
Apr
(51)
May
(86)
Jun
(131)
Jul
(91)
Aug
(90)
Sep
(83)
Oct
(149)
Nov
(131)
Dec
(242)
2007:
Jan
(139)
Feb
(78)
Mar
(187)
Apr
(117)
May
(90)
Jun
(88)
Jul
(95)
Aug
(73)
Sep
(53)
Oct
(63)
Nov
(69)
Dec
(34)
2008:
Jan
(31)
Feb
(51)
Mar
(48)
Apr
(64)
May
(57)
Jun
(78)
Jul
(106)
Aug
(101)
Sep
(255)
Oct
(319)
Nov
(420)
Dec
(114)
2009:
Jan
(100)
Feb
(93)
Mar
(53)
Apr
(92)
May
(162)
Jun
(90)
Jul
(116)
Aug
(35)
Sep
(88)
Oct
(47)
Nov
(15)
Dec
   
From: Bharat Mediratta <bharat@me...> - 2008-08-07 15:01
2.3 is just about out the door so it's time for us to start thinking
about what happens next. At the Gallery meetup this year, we had a
discussion about the state of the project, what we're doing well, what
we're doing poorly and some concrete steps that we can take to improve
things.

The project as a whole is doing well. We have lots of users, lots of
attention and are still the leading project in our field. We may not
have a huge developer community, but those that we have are talented
and passionate. We're continuing to make forward progress, make users
happy, and put out a high quality product. In other words, the
future of this particular market is in our hands to drive or fumble.

Things are not all rosy, though. We have problems that are eventually
going to lead to the slow demise of the project. These are things
that we can, and must fix in order to make this project the very best
that it can be. There are many issues, but they all culminate in one
major problem which is that we do not have enough people working on
the project. My main theory for this is because we have a product
that is too complex for the average casual hacker to come up to speed
on it. The developers that we have are highly skilled and well
versed, but the pool of talent that can produce such developers is
small and therefore we are always going to have a difficult time
growing them. Without more core developers, we will have a difficult
time really getting the critical mass we need to have a thriving
community. Without a thriving community, we will have a hard time
doing things like fixing the user interface, developing a set of
secondary support products (like Gallery Remote), taking advantage of
emerging technologies (WebDAV, OpenID), etc.

My theory for why we don't have enough developers is that Gallery 2 is
far too complex a product. I take the bulk of the responsibility for
this. Gallery 1 grew organically from specific needs and we had a
simple and pragmatic focus on adding features. It didn't always grow
in the right directions, but it was relatively simple to pick up,
understand and hack. But then I indulged myself when I created
Gallery 2 and blundered into making a classic mistake: the second
system effect[1]. Gallery 2 was designed to solve all problems well,
but in its ambition it really only solves most problems poorly.
Harsh? Perhaps. But if anybody has the right to throw the first
stone, I think it's me.

We discussed some plans for fixing this problem and they all boil down
to this: SIMPLIFY.

Let's get together and take a hard look at the product from a user
perspective. Make a list of all the features that users really care
about and then build the simplest implementation that meets them all.
Use pre-existing PHP5 frameworks wherever possible. Take advantage of
what PHP5 has to offer. *Ignore and delete* rarely used features.
Focus on the 80% of our users and build a product for them. Don't
worry about the screaming 20% who wants nifty new features, they are a
distraction. We should not be building a product that runs on 5
different databases and supports webdav, unless there's overwhelming
evidence of widespread use. Start at the top down by *building the
user interface FIRST* and then build the application to support it.
Make it dead simple to theme. Don't sacrifice security, but don't
generalize until we absolutely need it. Support migrating the core
data from Gallery 2.3, but be willing to throw out extra crap unless
it's obvious that we need it. Get rid of our complex permissions
system. Use a simple database structure! Make sure that it's easy to
embed in other apps using the hot new web 2.0 integration forms (RSS,
REST, JSON, etc). This is a very abbreviated list, we should have a
much longer discussion around our redesign constraints, but I'm throwing
these out there to give you an idea of how far I want to go.

We can refactor the existing product towards the goal, or we can do a
rewrite, but either way after we emerge from the design phase we will
implement the entire thing in THREE MONTHS. If we're not writing a
crapload of extra code it won't take us that long.

So that's my plan. Who's with me?

-Bharat

[1]: http://en.wikipedia.org/wiki/Second-system_effect


    From: Tim Almdal <tnalmdal@sh...> - 2008-08-07 15:40

    Attachments: Message as HTML     
    Sounds like a great plan and I whole heartedly agree with your comments, and simplification concept and approach.  I've been on the project for almost a year and half, and there are corners of gallery that i still haven't explored nor understand.

    We also need to tighten up the release cycles.  release cycles > year don't allow for a continued interest or respond to technology changes.

    I truly believe that a separation of the framework and the application is a key step in order to achieve simplicity.

    I can hardly wait to start

    Tim

    ----- Original Message -----
    From: Bharat Mediratta <bharat@me...>
    Date: Thursday, August 7, 2008 8:01 am
    Subject: [Gallery-devel] The road ahead for Gallery
    To: 'gallery-devel' <gallery-devel@li...>

    > 2.3 is just about out the door so it's time for us to start thinking
    > about what happens next. At the Gallery meetup this year, we had a
    > discussion about the state of the project, what we're doing
    > well, what
    > we're doing poorly and some concrete steps that we can take to improve
    > things.
    >
    > The project as a whole is doing well. We have lots of users,
    > lots of
    > attention and are still the leading project in our field. We may not
    > have a huge developer community, but those that we have are talented
    > and passionate. We're continuing to make forward progress, make users
    > happy, and put out a high quality product. In other words, the
    > future of this particular market is in our hands to drive or fumble.
    >
    > Things are not all rosy, though. We have problems that are eventually
    > going to lead to the slow demise of the project. These are things
    > that we can, and must fix in order to make this project the very best
    > that it can be. There are many issues, but they all culminate in one
    > major problem which is that we do not have enough people working on
    > the project. My main theory for this is because we have a product
    > that is too complex for the average casual hacker to come up to speed
    > on it. The developers that we have are highly skilled and well
    > versed, but the pool of talent that can produce such developers is
    > small and therefore we are always going to have a difficult time
    > growing them. Without more core developers, we will have a difficult
    > time really getting the critical mass we need to have a thriving
    > community. Without a thriving community, we will have a hard time
    > doing things like fixing the user interface, developing a set of
    > secondary support products (like Gallery Remote), taking
    > advantage of
    > emerging technologies (WebDAV, OpenID), etc.
    >
    > My theory for why we don't have enough developers is that
    > Gallery 2 is
    > far too complex a product. I take the bulk of the responsibility for
    > this. Gallery 1 grew organically from specific needs and we had a
    > simple and pragmatic focus on adding features. It didn't always grow
    > in the right directions, but it was relatively simple to pick up,
    > understand and hack. But then I indulged myself when I created
    > Gallery 2 and blundered into making a classic mistake: the second
    > system effect[1]. Gallery 2 was designed to solve all problems well,
    > but in its ambition it really only solves most problems poorly.
    > Harsh? Perhaps. But if anybody has the right to throw the first
    > stone, I think it's me.
    >
    > We discussed some plans for fixing this problem and they all
    > boil down
    > to this: SIMPLIFY.
    >
    > Let's get together and take a hard look at the product from a user
    > perspective. Make a list of all the features that users really care
    > about and then build the simplest implementation that meets them all.
    > Use pre-existing PHP5 frameworks wherever possible. Take
    > advantage of
    > what PHP5 has to offer. *Ignore and delete* rarely used features.
    > Focus on the 80% of our users and build a product for them. Don't
    > worry about the screaming 20% who wants nifty new features, they
    > are a
    > distraction. We should not be building a product that runs on 5
    > different databases and supports webdav, unless there's overwhelming
    > evidence of widespread use. Start at the top down by *building the
    > user interface FIRST* and then build the application to support it.
    > Make it dead simple to theme. Don't sacrifice security, but don't
    > generalize until we absolutely need it. Support migrating the core
    > data from Gallery 2.3, but be willing to throw out extra crap unless
    > it's obvious that we need it. Get rid of our complex permissions
    > system.  Use a simple database structure!  Make sure
    > that it's easy to
    > embed in other apps using the hot new web 2.0 integration forms
    > (RSS,
    > REST, JSON, etc).  This is a very abbreviated list, we
    > should have a
    > much longer discussion around our redesign constraints, but I'm
    > throwing
    > these out there to give you an idea of how far I want to go.
    >
    > We can refactor the existing product towards the goal, or we can
    > do a
    > rewrite, but either way after we emerge from the design phase we
    > will
    > implement the entire thing in THREE MONTHS. If we're not writing
    > a
    > crapload of extra code it won't take us that long.
    >
    > So that's my plan. Who's with me?
    >
    > -Bharat
    >
    > [1]: http://en.wikipedia.org/wiki/Second-system_effect
    >
    > -----------------------------------------------------------------
    > --------
    > This SF.Net email is sponsored by the Moblin Your Move
    > Developer's challenge
    > Build the coolest Linux based applications with Moblin SDK & win
    > great prizes
    > Grand prize is a trip for two to an Open Source event anywhere
    > in the world
    > http://moblin-contest.org/redirect.php?banner_id=100&url=/
    > __[ g a l l e r y - d e v e l ]_________________________
    >
    > [ list info/archive --> http://gallery.sf.net/lists.php ]
    > [ gallery info/FAQ/download --> http://gallery.sf.net ]
    >

    Website: http://www.timalmdal.com

    From: Jay Rossiter / Signe <signe@co...> - 2008-08-07 17:18
    Definitely behind this, and assuming I can tear myself free of the
    work schedule I've been on for the last 3.5 years, I want to be not just
    behind it, but in on it.

    Bharat Mediratta wrote:
    > 2.3 is just about out the door so it's time for us to start thinking
    > about what happens next. At the Gallery meetup this year, we had a
    > discussion about the state of the project, what we're doing well, what
    > we're doing poorly and some concrete steps that we can take to improve
    > things.
    >
    > The project as a whole is doing well. We have lots of users, lots of
    > attention and are still the leading project in our field. We may not
    > have a huge developer community, but those that we have are talented
    > and passionate. We're continuing to make forward progress, make users
    > happy, and put out a high quality product. In other words, the
    > future of this particular market is in our hands to drive or fumble.
    >
    > Things are not all rosy, though. We have problems that are eventually
    > going to lead to the slow demise of the project. These are things
    > that we can, and must fix in order to make this project the very best
    > that it can be. There are many issues, but they all culminate in one
    > major problem which is that we do not have enough people working on
    > the project. My main theory for this is because we have a product
    > that is too complex for the average casual hacker to come up to speed
    > on it. The developers that we have are highly skilled and well
    > versed, but the pool of talent that can produce such developers is
    > small and therefore we are always going to have a difficult time
    > growing them. Without more core developers, we will have a difficult
    > time really getting the critical mass we need to have a thriving
    > community. Without a thriving community, we will have a hard time
    > doing things like fixing the user interface, developing a set of
    > secondary support products (like Gallery Remote), taking advantage of
    > emerging technologies (WebDAV, OpenID), etc.
    >
    > My theory for why we don't have enough developers is that Gallery 2 is
    > far too complex a product. I take the bulk of the responsibility for
    > this. Gallery 1 grew organically from specific needs and we had a
    > simple and pragmatic focus on adding features. It didn't always grow
    > in the right directions, but it was relatively simple to pick up,
    > understand and hack. But then I indulged myself when I created
    > Gallery 2 and blundered into making a classic mistake: the second
    > system effect[1]. Gallery 2 was designed to solve all problems well,
    > but in its ambition it really only solves most problems poorly.
    > Harsh? Perhaps. But if anybody has the right to throw the first
    > stone, I think it's me.
    >
    > We discussed some plans for fixing this problem and they all boil down
    > to this: SIMPLIFY.
    >
    > Let's get together and take a hard look at the product from a user
    > perspective. Make a list of all the features that users really care
    > about and then build the simplest implementation that meets them all.
    > Use pre-existing PHP5 frameworks wherever possible. Take advantage of
    > what PHP5 has to offer. *Ignore and delete* rarely used features.
    > Focus on the 80% of our users and build a product for them. Don't
    > worry about the screaming 20% who wants nifty new features, they are a
    > distraction. We should not be building a product that runs on 5
    > different databases and supports webdav, unless there's overwhelming
    > evidence of widespread use. Start at the top down by *building the
    > user interface FIRST* and then build the application to support it.
    > Make it dead simple to theme. Don't sacrifice security, but don't
    > generalize until we absolutely need it. Support migrating the core
    > data from Gallery 2.3, but be willing to throw out extra crap unless
    > it's obvious that we need it. Get rid of our complex permissions
    > system. Use a simple database structure! Make sure that it's easy to
    > embed in other apps using the hot new web 2.0 integration forms (RSS,
    > REST, JSON, etc). This is a very abbreviated list, we should have a
    > much longer discussion around our redesign constraints, but I'm throwing
    > these out there to give you an idea of how far I want to go.
    >
    > We can refactor the existing product towards the goal, or we can do a
    > rewrite, but either way after we emerge from the design phase we will
    > implement the entire thing in THREE MONTHS. If we're not writing a
    > crapload of extra code it won't take us that long.
    >
    > So that's my plan. Who's with me?
    >
    > -Bharat
    >
    > [1]: http://en.wikipedia.org/wiki/Second-system_effect
    >
    > -------------------------------------------------------------------------
    > This SF.Net email is sponsored by the Moblin Your Move Developer's challenge
    > Build the coolest Linux based applications with Moblin SDK & win great prizes
    > Grand prize is a trip for two to an Open Source event anywhere in the world
    > http://moblin-contest.org/redirect.php?banner_id=100&url=/
    > __[ g a l l e r y - d e v e l ]_________________________
    >
    > [ list info/archive --> http://gallery.sf.net/lists.php ]
    > [ gallery info/FAQ/download --> http://gallery.sf.net ]
    >


    --
    Jay Rossiter http://www.cothlamadh.net/
    503.477.8428 signe@co...

    From: Michael Schultheiss <schultmc@de...> - 2008-08-07 17:40
    Bharat Mediratta wrote:
    > So that's my plan. Who's with me?

    I'm all for this. Gallery 2 is an extremely complex piece of software -
    simplifying it considerably would ease maintenance concerns and allow
    more people to hack on it.

    --
    ----------------------------
    Michael Schultheiss
    E-mail: schultmc@de...

    From: Dariush Molavi <dmolavi@th...> - 2008-08-07 19:19
    +1 from me. One reason I can't contribute as much as I like is the layers
    of complexity that have outpaced me.

    You hit the nail on the head re: users...the perceived complexity of G2 is
    precisely why my friends/family don't use it.

    I'm with you. G2 need not be bloatware (plugins for scrambling eggs,
    scratching you ass, etc), there's plenty of that out there without us
    adding to it.

    On Thu, 7 Aug 2008, Bharat Mediratta wrote:

    > 2.3 is just about out the door so it's time for us to start thinking
    > about what happens next. At the Gallery meetup this year, we had a
    > discussion about the state of the project, what we're doing well, what
    > we're doing poorly and some concrete steps that we can take to improve
    > things.
    >
    > The project as a whole is doing well. We have lots of users, lots of
    > attention and are still the leading project in our field. We may not
    > have a huge developer community, but those that we have are talented
    > and passionate. We're continuing to make forward progress, make users
    > happy, and put out a high quality product. In other words, the
    > future of this particular market is in our hands to drive or fumble.
    >
    > Things are not all rosy, though. We have problems that are eventually
    > going to lead to the slow demise of the project. These are things
    > that we can, and must fix in order to make this project the very best
    > that it can be. There are many issues, but they all culminate in one
    > major problem which is that we do not have enough people working on
    > the project. My main theory for this is because we have a product
    > that is too complex for the average casual hacker to come up to speed
    > on it. The developers that we have are highly skilled and well
    > versed, but the pool of talent that can produce such developers is
    > small and therefore we are always going to have a difficult time
    > growing them. Without more core developers, we will have a difficult
    > time really getting the critical mass we need to have a thriving
    > community. Without a thriving community, we will have a hard time
    > doing things like fixing the user interface, developing a set of
    > secondary support products (like Gallery Remote), taking advantage of
    > emerging technologies (WebDAV, OpenID), etc.
    >
    > My theory for why we don't have enough developers is that Gallery 2 is
    > far too complex a product. I take the bulk of the responsibility for
    > this. Gallery 1 grew organically from specific needs and we had a
    > simple and pragmatic focus on adding features. It didn't always grow
    > in the right directions, but it was relatively simple to pick up,
    > understand and hack. But then I indulged myself when I created
    > Gallery 2 and blundered into making a classic mistake: the second
    > system effect[1]. Gallery 2 was designed to solve all problems well,
    > but in its ambition it really only solves most problems poorly.
    > Harsh? Perhaps. But if anybody has the right to throw the first
    > stone, I think it's me.
    >
    > We discussed some plans for fixing this problem and they all boil down
    > to this: SIMPLIFY.
    >
    > Let's get together and take a hard look at the product from a user
    > perspective. Make a list of all the features that users really care
    > about and then build the simplest implementation that meets them all.
    > Use pre-existing PHP5 frameworks wherever possible. Take advantage of
    > what PHP5 has to offer. *Ignore and delete* rarely used features.
    > Focus on the 80% of our users and build a product for them. Don't
    > worry about the screaming 20% who wants nifty new features, they are a
    > distraction. We should not be building a product that runs on 5
    > different databases and supports webdav, unless there's overwhelming
    > evidence of widespread use. Start at the top down by *building the
    > user interface FIRST* and then build the application to support it.
    > Make it dead simple to theme. Don't sacrifice security, but don't
    > generalize until we absolutely need it. Support migrating the core
    > data from Gallery 2.3, but be willing to throw out extra crap unless
    > it's obvious that we need it. Get rid of our complex permissions
    > system. Use a simple database structure! Make sure that it's easy to
    > embed in other apps using the hot new web 2.0 integration forms (RSS,
    > REST, JSON, etc). This is a very abbreviated list, we should have a
    > much longer discussion around our redesign constraints, but I'm throwing
    > these out there to give you an idea of how far I want to go.
    >
    > We can refactor the existing product towards the goal, or we can do a
    > rewrite, but either way after we emerge from the design phase we will
    > implement the entire thing in THREE MONTHS. If we're not writing a
    > crapload of extra code it won't take us that long.
    >
    > So that's my plan. Who's with me?
    >
    > -Bharat
    >
    > [1]: http://en.wikipedia.org/wiki/Second-system_effect
    >
    > -------------------------------------------------------------------------
    > This SF.Net email is sponsored by the Moblin Your Move Developer's challenge
    > Build the coolest Linux based applications with Moblin SDK & win great prizes
    > Grand prize is a trip for two to an Open Source event anywhere in the world
    > http://moblin-contest.org/redirect.php?banner_id=100&url=/
    > __[ g a l l e r y - d e v e l ]_________________________
    >
    > [ list info/archive --> http://gallery.sf.net/lists.php ]
    > [ gallery info/FAQ/download --> http://gallery.sf.net ]
    >

    From: R.Nagy József <jozsef.rnagy@si...> - 2008-08-07 19:34
    Agreed:
    - project needs more, regularly active developers onboard (eg not ppl
    like me 'lately')
    - to achieve this, code needs to simplified, just as said, and the
    process of getting new modules/improvements into <whatever repo> needs
    to be transparent and shortened for anyone (ppl get bored/lose
    motivation quickly)
    - theming and UI must be simplified too, means great improvement from
    users' and less technically (codewise) oriented designers' point of view

    Comments:
    - As the number of committing developers grows, the harder it will be
    to keep things secure and _tested_, something that shall not be
    satisfied imo, this -among others- keeps Gallery an outstanding product.
    The need for unit tests itself -and understanding that system first of
    all- scares off most dudes I've talked with. It's gonna be a great
    challenge to keep tests etc in, but make it simple enough.

    - "THREE MONTHS" : sounds good, but you can not expect new ppl to take
    on it - and most likely that would not be a good idea anyway-, so it
    has to be done by current developers. After taking a look at the
    current list and size of core and other modules, 3 months is a very
    short time, rewrite is not realistic imho, but refactoring from the
    base would be nice.

    Who is with you in making G2 an even better, more widely used product?
    Of course I am (as much as possible).
    --
    Joe


    Idézet (Bharat Mediratta <bharat@me...>):

    > 2.3 is just about out the door so it's time for us to start thinking
    > about what happens next. At the Gallery meetup this year, we had a
    > discussion about the state of the project, what we're doing well, what
    > we're doing poorly and some concrete steps that we can take to improve
    > things.
    >
    > The project as a whole is doing well. We have lots of users, lots of
    > attention and are still the leading project in our field. We may not
    > have a huge developer community, but those that we have are talented
    > and passionate. We're continuing to make forward progress, make users
    > happy, and put out a high quality product. In other words, the
    > future of this particular market is in our hands to drive or fumble.
    >
    > Things are not all rosy, though. We have problems that are eventually
    > going to lead to the slow demise of the project. These are things
    > that we can, and must fix in order to make this project the very best
    > that it can be. There are many issues, but they all culminate in one
    > major problem which is that we do not have enough people working on
    > the project. My main theory for this is because we have a product
    > that is too complex for the average casual hacker to come up to speed
    > on it. The developers that we have are highly skilled and well
    > versed, but the pool of talent that can produce such developers is
    > small and therefore we are always going to have a difficult time
    > growing them. Without more core developers, we will have a difficult
    > time really getting the critical mass we need to have a thriving
    > community. Without a thriving community, we will have a hard time
    > doing things like fixing the user interface, developing a set of
    > secondary support products (like Gallery Remote), taking advantage of
    > emerging technologies (WebDAV, OpenID), etc.
    >
    > My theory for why we don't have enough developers is that Gallery 2 is
    > far too complex a product. I take the bulk of the responsibility for
    > this. Gallery 1 grew organically from specific needs and we had a
    > simple and pragmatic focus on adding features. It didn't always grow
    > in the right directions, but it was relatively simple to pick up,
    > understand and hack. But then I indulged myself when I created
    > Gallery 2 and blundered into making a classic mistake: the second
    > system effect[1]. Gallery 2 was designed to solve all problems well,
    > but in its ambition it really only solves most problems poorly.
    > Harsh? Perhaps. But if anybody has the right to throw the first
    > stone, I think it's me.
    >
    > We discussed some plans for fixing this problem and they all boil down
    > to this: SIMPLIFY.
    >
    > Let's get together and take a hard look at the product from a user
    > perspective. Make a list of all the features that users really care
    > about and then build the simplest implementation that meets them all.
    > Use pre-existing PHP5 frameworks wherever possible. Take advantage of
    > what PHP5 has to offer. *Ignore and delete* rarely used features.
    > Focus on the 80% of our users and build a product for them. Don't
    > worry about the screaming 20% who wants nifty new features, they are a
    > distraction. We should not be building a product that runs on 5
    > different databases and supports webdav, unless there's overwhelming
    > evidence of widespread use. Start at the top down by *building the
    > user interface FIRST* and then build the application to support it.
    > Make it dead simple to theme. Don't sacrifice security, but don't
    > generalize until we absolutely need it. Support migrating the core
    > data from Gallery 2.3, but be willing to throw out extra crap unless
    > it's obvious that we need it. Get rid of our complex permissions
    > system. Use a simple database structure! Make sure that it's easy to
    > embed in other apps using the hot new web 2.0 integration forms (RSS,
    > REST, JSON, etc). This is a very abbreviated list, we should have a
    > much longer discussion around our redesign constraints, but I'm throwing
    > these out there to give you an idea of how far I want to go.
    >
    > We can refactor the existing product towards the goal, or we can do a
    > rewrite, but either way after we emerge from the design phase we will
    > implement the entire thing in THREE MONTHS. If we're not writing a
    > crapload of extra code it won't take us that long.
    >
    > So that's my plan. Who's with me?
    >
    > -Bharat
    >
    > [1]: http://en.wikipedia.org/wiki/Second-system_effect
    >
    > -------------------------------------------------------------------------
    > This SF.Net email is sponsored by the Moblin Your Move Developer's challenge
    > Build the coolest Linux based applications with Moblin SDK & win great prizes
    > Grand prize is a trip for two to an Open Source event anywhere in the world
    > http://moblin-contest.org/redirect.php?banner_id=100&url=/
    > __[ g a l l e r y - d e v e l ]_________________________
    >
    > [ list info/archive --> http://gallery.sf.net/lists.php ]
    > [ gallery info/FAQ/download --> http://gallery.sf.net ]
    >

    From: Jan Hendrik Mangold <jhm@co...> - 2008-08-07 19:37
    On 7 Aug 2008, at 08:01, Bharat Mediratta wrote:

    > So that's my plan. Who's with me?

    I am with you and want to contribute (lest my day-job keeps me
    shackled ...) since I am a LONG time gallery user, but frankly never
    had the time to dive into the g2 framework to understand it enough to
    submit meaningful contributions.

    Cheers,
    Jan

    From: Andy Staudacher <andy.st@gm...> - 2008-08-07 22:15

    Attachments: Message as HTML     
    2008/8/7 R.Nagy József <jozsef.rnagy@si...>

    > Agreed:
    > - project needs more, regularly active developers onboard (eg not ppl
    > like me 'lately')
    > - to achieve this, code needs to simplified, just as said, and the
    > process of getting new modules/improvements into <whatever repo> needs
    > to be transparent and shortened for anyone (ppl get bored/lose
    > motivation quickly)
    > - theming and UI must be simplified too, means great improvement from
    > users' and less technically (codewise) oriented designers' point of view
    >
    > Comments:
    > - As the number of committing developers grows, the harder it will be
    > to keep things secure and _tested_, something that shall not be
    > satisfied imo, this -among others- keeps Gallery an outstanding product.
    > The need for unit tests itself -and understanding that system first of
    > all- scares off most dudes I've talked with. It's gonna be a great
    > challenge to keep tests etc in, but make it simple enough.
    >
    > - "THREE MONTHS" : sounds good, but you can not expect new ppl to take
    > on it - and most likely that would not be a good idea anyway-, so it
    > has to be done by current developers. After taking a look at the
    > current list and size of core and other modules, 3 months is a very
    > short time, rewrite is not realistic imho, but refactoring from the
    > base would be nice.


    Very good points.

    @Tests or How simple is simple enough?
    - Requiring unit tests is a huge barrier.
    - Keeping unit tests around, i.e. designing the application for testability,
    requires some abstractions (e.g. GalleryPhpVm) which raise the barrier and
    add bumps to the learning curve.
    - Accepting but not requiring tests will lead to breakage of existing tests
    and a lot of maintenance work for the few that declare to keep the tests up
    to date.
    - Dropping unit tests is bad in the long term. Even when the core
    application is slimmed down, we'll need test automation for QA.
    - Drupal, typo3 and other open source PHP projects have started without test
    automation and some of them have added or are adding tests right now and are
    willing to require tests for all core code submissions.

    I think the key is to keep the core code / the official core project
    reasonably small.

    We don't have to dumb down the code design of the core application. It's
    sufficient if we make it a lot simpler than it is now. And there is a lot of
    potential to make it simpler without getting rid of useful abstractions and
    design patterns.

    We can then design the core with proper abstractions, designing for
    testability and still provide a reasonably simple code base.
    The goal would be that you could do pretty much everything with Gallery
    without having to modify the code base of the core.

    Much more code would live outside of the core application. I guess there
    could be a list of officially maintained plugins (not part of the core
    project) and 3rd party plugins.

    For the core project we'd still require tests, for official and 3rd party
    plugins we'd have maintainers that have their own authority on how to ensure
    QA, with or without test automation.

    There are lessons we can learn from typo3 and other projects in putting
    processes into place for code and security reviews of non-core code. End
    users could then decide to only use 3rd party plugin releases that have been
    audited for quality and security.

    And there are lessons to be learned from projects that have started with
    usability and simplicity in mind like Zenphoto. You can start too simple (no
    internationalization, no plugin system) and then get into problems when you
    need to add all the features people are asking for. We learned some of those
    lessons with G1 already.


    @three months:
    I think 3 months is unrealistic to implement a lot of drastic changes.
    If you had 2-4 full time engineers you could do it in 1-2 months. If you
    have ~3 engineers working on and off 5-15h a week on this project and have
    many other things on their mind, then you need a lot more time.

    Either way, let's talk about the time frame later. Let's first talk about
    things that we'd like to change. Let's come up with UI ideas, features that
    should be in there. And then let's talk how the UI and those features should
    be backed by an application / framework. And then we can talk about how to
    tackle this, incrementally or not.


    @what future do we want to have?
    Everything that has been said is very true. G2 is too complex, G2 needs a
    thriving developer community to survive and making things simpler is they
    key to get there.
    Say we achieve all that. We release the next generation (NG) version of
    Gallery. Gallery-NG is a pleasure to use, it's simpler to hack, easier to
    maintain, etc.
    Where do you see the project in 2 years?
    Despite being such a great product, will there still be a market for
    Gallery?

    I find myself recommending Flickr, picasaweb and other photo hosting
    services to people that just want to share their images and don't have any
    technical background. Even with neat auto installers, even an easy to
    install web application requires maintenance (upgrades) and it requires more
    technical knowledge to create a webhosting account than to create a Flickr
    account.

    Gallery (1) was once the best and easiest way to share your photos on the
    web. That was at a time before there were social networks and photo
    sharingwebsites.
    Things have changed and the target audience for self hosted web applications
    is much smaller today. Is it smaller in absolute numbers? I don't know.

    And for people who prefer having their own website but don't want to deal
    with all the maintenance, there are thin solutions that let you present your
    Flickr / picasaweb photo albums on your own website.

    So who is still interested in Gallery? What's the audience we want to target
    this simplified Gallery application for?

    Your mom? No, she'd be a user of a photo hosting service. Well, unless
    you're the maintainer of that service, based on Gallery-NG.

    *It's about people who enjoy freedom. Freedom not to be limited by the
    design or feature limitations of a photo service. Freedom to post any kind
    of photo / video without worrying that the service cancels your account or
    deletes your photos without notice.

    It's about people who would like to build their own website and may even
    have fun doing the occasional upgrades and discovering new features and
    improvements.

    It's about people who host their own (small?) community website. Integration
    features are key in this segment. Scalability as well.
    *
    The bulk of the market is using social websites and photo sharing services.
    It's a niche. But an important niche.

    <sidenote>
    As a sidenote, I see G2 as a special purpose CMS, or application specific
    CMS. It's got most of the infrastructure to be a step away from a really
    nice CMS, but it never made that step. It didn't because it's too complex to
    attract a larger developer community to thrive a diversification into other
    markets.
    So this Gallery-NG will probably be farther away from being a CMS. It would
    be simpler, even more application specific.
    </sidenote>

    So, that's what's left of the market after taking social websites and photo
    sharing services into account.
    What about general purpose content management systems (CMS)?
    CMS are growing into Gallery's market as well.

    Although we invested quite a lot of effort into designing G2 for
    integration, we are very far from doing an excellent job in this regard.
    Mostly because integration is too complex. I can take the bulk of the blame
    for that, yay!
    And Gallery didn't provide the more modern means to integrate (RSS, RESTful
    APIs, etc.).

    When talking about integration, there are basically two markets:
    - Integration into mostly static websites, mostly for presentation
    (displaying an album, or a slideshow on some website).
    - Tight integration with a CMS assuming responsibilities for all matters
    related to photo (or even media) management.

    My efforts have been mostly targeting the latter market. Mostly, we made
    tight integration possible, but still too complex.
    I'd define success as most PHP CMS using Gallery for photo (or even media)
    management and presentation. Everything else leads to too much duplication
    and segmentation of effort. If the bulk of the talent pool could innovate
    based on the same code base, everyone would get a lot more out their
    investment.

    That's not where we are. CMS are implementing their own image / media
    management solutions.

    So let's look into the future again. 2 years from now, CMS like drupal are
    still growing their community at an impressive rate and they'll come with
    excellent image management features and all the other goodness that their
    CMS community provides (mature core project, tons and tons of docs and
    books, groups working on usability, security, scalability, you name it).
    They'd have learned their lessons as well and provide application specific
    installation profiles (similar to Eclipse, that's where Drupal is headed)
    and thus provide an easy to install Gallery application without having to
    configure all the CMS options / plugins to get there.

    >From the niche that is left after taking photo hosting services into
    account, what would be left after taking such CMS solutions into account as
    well?

    Remember what's left after taking services into account (see above).
    Integration is key for most of the remaining users.
    It's going to be hard to compete for this shrinking market. It's a fight at
    two fronts.

    Our declared goal is to provide a "best of breed" product and to seamlessly
    integrate with applications from other areas.

    Either we'd need to give up on tight integration and focus on providing the
    RSS, REST APIs for integration with small websites, social networking
    websites etc.
    And we'd lose another piece of the market.

    Or we'd need to keep the gap between our solution and what general purpose
    CMS can provide reasonably large, else there's not much incentive to jump
    through the hoops required to maintain and integrate multiple applications.
    And we'd need to focus even more on tight integration (this is not about
    RSS, REST, more about session, user management, search integration, content
    management features (e.g. providing some album / item to the CMS via an
    API), template systems, etc.).
    Which might be at odds with our goal of simplifying things and which
    certainly requires quite some development effort.

    Conclusion:
    Gallery as a project might not grow much even though we might be doing
    everything right. That's because the niche in which we operate is a
    shrinking piece of the market, fighting service oriented solutions on one
    front and CMS solutions on the other.

    I see a lot of reasons to believe that Gallery will be more fun to work on
    in the future that we all envision.
    And that might be enough reason to make these things happen. No matter
    whether Gallery's niche is shrinking, no matter whether there's much
    potential to grow Gallery's market share.

    So, what future do we want to have?
    Do you want to spend time working in this niche? What's your definition of
    this niche market, who are the customers you'd like to have?
    As a developer / contributor, you have to find an answer to that question
    yourself.

    As for integration matters, I think more discussion is needed. We'll know
    more once we talk more concrete about the design of Gallery-NG.

    - Andy


    >
    > Who is with you in making G2 an even better, more widely used product?
    > Of course I am (as much as possible).
    > --
    > Joe
    >
    >
    > Idézet (Bharat Mediratta <bharat@me...>):
    >
    > > 2.3 is just about out the door so it's time for us to start thinking
    > > about what happens next. At the Gallery meetup this year, we had a
    > > discussion about the state of the project, what we're doing well, what
    > > we're doing poorly and some concrete steps that we can take to improve
    > > things.
    > >
    > > The project as a whole is doing well. We have lots of users, lots of
    > > attention and are still the leading project in our field. We may not
    > > have a huge developer community, but those that we have are talented
    > > and passionate. We're continuing to make forward progress, make users
    > > happy, and put out a high quality product. In other words, the
    > > future of this particular market is in our hands to drive or fumble.
    > >
    > > Things are not all rosy, though. We have problems that are eventually
    > > going to lead to the slow demise of the project. These are things
    > > that we can, and must fix in order to make this project the very best
    > > that it can be. There are many issues, but they all culminate in one
    > > major problem which is that we do not have enough people working on
    > > the project. My main theory for this is because we have a product
    > > that is too complex for the average casual hacker to come up to speed
    > > on it. The developers that we have are highly skilled and well
    > > versed, but the pool of talent that can produce such developers is
    > > small and therefore we are always going to have a difficult time
    > > growing them. Without more core developers, we will have a difficult
    > > time really getting the critical mass we need to have a thriving
    > > community. Without a thriving community, we will have a hard time
    > > doing things like fixing the user interface, developing a set of
    > > secondary support products (like Gallery Remote), taking advantage of
    > > emerging technologies (WebDAV, OpenID), etc.
    > >
    > > My theory for why we don't have enough developers is that Gallery 2 is
    > > far too complex a product. I take the bulk of the responsibility for
    > > this. Gallery 1 grew organically from specific needs and we had a
    > > simple and pragmatic focus on adding features. It didn't always grow
    > > in the right directions, but it was relatively simple to pick up,
    > > understand and hack. But then I indulged myself when I created
    > > Gallery 2 and blundered into making a classic mistake: the second
    > > system effect[1]. Gallery 2 was designed to solve all problems well,
    > > but in its ambition it really only solves most problems poorly.
    > > Harsh? Perhaps. But if anybody has the right to throw the first
    > > stone, I think it's me.
    > >
    > > We discussed some plans for fixing this problem and they all boil down
    > > to this: SIMPLIFY.
    > >
    > > Let's get together and take a hard look at the product from a user
    > > perspective. Make a list of all the features that users really care
    > > about and then build the simplest implementation that meets them all.
    > > Use pre-existing PHP5 frameworks wherever possible. Take advantage of
    > > what PHP5 has to offer. *Ignore and delete* rarely used features.
    > > Focus on the 80% of our users and build a product for them. Don't
    > > worry about the screaming 20% who wants nifty new features, they are a
    > > distraction. We should not be building a product that runs on 5
    > > different databases and supports webdav, unless there's overwhelming
    > > evidence of widespread use. Start at the top down by *building the
    > > user interface FIRST* and then build the application to support it.
    > > Make it dead simple to theme. Don't sacrifice security, but don't
    > > generalize until we absolutely need it. Support migrating the core
    > > data from Gallery 2.3, but be willing to throw out extra crap unless
    > > it's obvious that we need it. Get rid of our complex permissions
    > > system. Use a simple database structure! Make sure that it's easy to
    > > embed in other apps using the hot new web 2.0 integration forms (RSS,
    > > REST, JSON, etc). This is a very abbreviated list, we should have a
    > > much longer discussion around our redesign constraints, but I'm throwing
    > > these out there to give you an idea of how far I want to go.
    > >
    > > We can refactor the existing product towards the goal, or we can do a
    > > rewrite, but either way after we emerge from the design phase we will
    > > implement the entire thing in THREE MONTHS. If we're not writing a
    > > crapload of extra code it won't take us that long.
    > >
    > > So that's my plan. Who's with me?
    > >
    > > -Bharat
    > >
    > > [1]: http://en.wikipedia.org/wiki/Second-system_effect
    > >
    > > -------------------------------------------------------------------------
    > > This SF.Net email is sponsored by the Moblin Your Move Developer's
    > challenge
    > > Build the coolest Linux based applications with Moblin SDK & win great
    > prizes
    > > Grand prize is a trip for two to an Open Source event anywhere in the
    > world
    > > http://moblin-contest.org/redirect.php?banner_id=100&url=/
    > > __[ g a l l e r y - d e v e l ]_________________________
    > >
    > > [ list info/archive --> http://gallery.sf.net/lists.php ]
    > > [ gallery info/FAQ/download --> http://gallery.sf.net ]
    > >
    >
    >
    >
    >
    > -------------------------------------------------------------------------
    > This SF.Net email is sponsored by the Moblin Your Move Developer's
    > challenge
    > Build the coolest Linux based applications with Moblin SDK & win great
    > prizes
    > Grand prize is a trip for two to an Open Source event anywhere in the world
    > http://moblin-contest.org/redirect.php?banner_id=100&url=/
    > __[ g a l l e r y - d e v e l ]_________________________
    >
    > [ list info/archive --> http://gallery.sf.net/lists.php ]
    > [ gallery info/FAQ/download --> http://gallery.sf.net ]
    >
    >

    From: Bharat Mediratta <bharat@me...> - 2008-08-08 01:36
    Bharat Mediratta wrote:
    > 2.3 is just about out the door so it's time for us to start thinking
    ...

    I'll blasphemously respond to my own post just to mention that this got
    picked up on reddit where there's some interesting discussion taking place:

    http://www.reddit.com/comments/6vcfs/my_main_theory_for_this_is_because_we_have_a/

    I don't like to bifurcate the conversation, but I do think that some
    interesting concepts and questions raised there, including Third Version
    Effect:
    http://c2.com/cgi/wiki?ThirdVersionEffect

    A few "why didn't they just do X" questions, that are mostly too
    difficult to answer well in a forum like that. But interesting readiny
    nonetheless.

    I'm in New Hampshire for the weekend so I'm going to have low
    availability for a bit (taking the kids to play with their grandparents)
    but I will be starting off next week with my vision for what stays and
    what goes in the next version.

    There are 250+ people on this list. I encourage *each and every one of
    you* to take a moment to reply to this thread to weigh in with your
    opinion about what we should do next. Please. Your input is valuable
    and there has never been a better time for your voice to be heard.

    -Bharat

    From: Walid Moghrabi <walid.moghrabi@le...> - 2008-08-08 16:32

    Attachments: Message as HTML      logo_couleur_petit.jpg     


    From: Walid Moghrabi <walid.moghrabi@le...> - 2008-08-08 17:11

    Attachments: Message as HTML      logo_couleur_petit.jpg     


    From: Gaynor McCartney <gaynormcc@xt...> - 2008-08-09 02:19

    Attachments: Message as HTML     
    Hi all,
    I find this interesting, at this time when I am just getting back into Gallery deeps again after several months..
     
    I think perhaps I am one of the "not quite geeks" who find gallery exciting, because it offers "personalisation" that is not found in a lot of programmes.
    It allows us to put our own mark on our work, and as has been mentioned that wonderful freedom, while also being very careful of security.
     
    Things I have found a bit difficult include :-
    ** the frequent upgrades - we just get used to one and the next comes out.
    That was fine in G1 where I could do them myself, but in G2 they require skills I do not have. Sure the logical thing is for me to learn MYSQL etc, but to keep fluent in that sort of thing one must use it regularly -- which I don;t and would not.
    I would hope that in future the Gallery can be upgraded from within the Gallery programme - presumably in the Site Admin section.
     
    ** The Reply function of this list annoys in that Hitting reply only sends to the sender of the message being answered. I often use my webmail, and it does not give me a "Reply All" feature.
     
    ** Difficulties for "Half Baked Geek users" like me.
    You'll have noticed that coming back into gallery work, I have difficulty remembering things I was familiar with before. I think we probably have a large group of users with the same problem, and yes, they love Gallery and want to be able to revise quickly and get back to work.
    ** The documentation is far and away better than it used to be, (many thanks), but it is still diffiicult to actually FIND the information we need. When someone points me to it, all I need is there, but I do feel guilty for taking that other person's time.
     
    ##  I agree with the idea of a main core Gallery with lots of plugins, both official and 3rd party.
    That way we can use only those features we want on our site. Also the Upgrades in the core do not necessarily require changes in the plugins, making the upgrades smaller.
     
    ## I'd also like us to have a library of ALL the things that were in 3rd Party User section as some of the earlier ones were beautifully simple, or just much loved... (It was interesting to discover that the PG theme is no longer listed anywhere that I could see. It was not available for a new intallation of the current Gallery, while it works perfectly in my upgraded galleries. I have yet to discover whether I like Xtreme theme as a substitute for PG, but I lived with PG theme for so looooong and made real friends with it, and am reluctant to let it go.)
     
    ## I believe any plugin or new feature should have clear, simple, layperson's language description of what it does and instructions for using it.
    I discovered a section in the upgraded G2 the other night, where clicking to select image frames gives a popup showing samples... wonderful ... we should have that for themes, colorpacks etc.
    # New features (new to Gallery but possibly 'old hat' in 'the industry' should show examples. The newer versions of PG theme scared me off when they talked of Lightbox ... which I had no idea what that meant.... and frankly the name does not, to me, describe the feature.
    # Do we have an index of features? giving description and where to find them.(where creators of new features add their own appropriately)
     
    ## Perhaps our themes should each be required to have a "Using this theme" Section (or call it "About this theme " instructions, or even FAQ). I am sure I still do not know all the things that can be done with PG for eg.
    [[Working on that sort of documentation would interst me, but I work in fits and starts so could not be the only one]]
     
    Perhaps it all boils down to Security, Simplicity, and Flexibility.

    Regards,
    Gaynor McCartney
    http://www.piopionz.com
    http://www.tekuiti-nz.com
    http://www.come2see.co.nz  - my infant new venture

    --- On Sat, 9/8/08, Walid Moghrabi <walid.moghrabi@le...> wrote:

    From: Walid Moghrabi <walid.moghrabi@le...>
    Subject: Re: [Gallery-devel] The road ahead for Gallery
    To: gallery-devel@li...
    Received: Saturday, 9 August, 2008, 5:11 AM


    Hi everyone,

    @Tests or How simple is simple enough?
    - Requiring unit tests is a huge barrier.
    - Keeping unit tests around, i.e. designing the application for testability, requires some abstractions (e.g. GalleryPhpVm) which raise the barrier and add bumps to the learning curve.
    - Accepting but not requiring tests will lead to breakage of existing tests and a lot of maintenance work for the few that declare to keep the tests up to date.
    - Dropping unit tests is bad in the long term. Even when the core application is slimmed down, we'll need test automation for QA.
    - Drupal, typo3 and other open source PHP projects have started without test automation and some of them have added or are adding tests right now and are willing to require tests for all core code submissions.

    I think the key is to keep the core code / the official core project reasonably small.

    We don't have to dumb down the code design of the core application. It's sufficient if we make it a lot simpler than it is now. And there is a lot of potential to make it simpler without getting rid of useful abstractions and design patterns.

    We can then design the core with proper abstractions, designing for testability and still provide a reasonably simple code base.
    The goal would be that you could do pretty much everything with Gallery without having to modify the code base of the core.

    Much more code would live outside of the core application. I guess there could be a list of officially maintained plugins (not part of the core project) and 3rd party plugins.

    For the core project we'd still require tests, for official and 3rd party plugins we'd have maintainers that have their own authority on how to ensure QA, with or without test automation.

    There are lessons we can learn from typo3 and other projects in putting processes into place for code and security reviews of non-core code. End users could then decide to only use 3rd party plugin releases that have been audited for quality and security.

    And there are lessons to be learned from projects that have started with usability and simplicity in mind like Zenphoto. You can start too simple (no internationalization, no plugin system) and then get into problems when you need to add all the features people are asking for. We learned some of those lessons with G1 already.

    Removing unit tests is certainly a bad idea but as said in other posts, the documentation is somewhat incomplete or outdated and that's true that it doesn't help new coders to get into it easily.
    So for sure, there is a lot of work to be done on the documentation part.
    Concerning unit tests, why not building a "test team" which would be dedicated to the validation of code from contributors instead of making the unit tests the developper's work (which is, in my opinion, an heresy) ?
    Coders should code ... this is a bad idea to make them test their own stuff because most of the time, they'll miss bugs simply becuse they don't think like the end user.



    @three months:
    I think 3 months is unrealistic to implement a lot of drastic changes.
    If you had 2-4 full time engineers you could do it in 1-2 months. If you have ~3 engineers working on and off 5-15h a week on this project and have many other things on their mind, then you need a lot more time.

    Either way, let's talk about the time frame later. Let's first talk about things that we'd like to change. Let's come up with UI ideas, features that should be in there. And then let's talk how the UI and those features should be backed by an application / framework. And then we can talk about how to tackle this, incrementally or not.

    G2 is a fairly complex piece of work, 3 month seems utopist for rewriting it but this could be possible to clean up documentation and rework some important parts such as theming engine or ACL handling.



    @what future do we want to have?
    Everything that has been said is very true. G2 is too complex, G2 needs a thriving developer community to survive and making things simpler is they key to get there.
    Say we achieve all that. We release the next generation (NG) version of Gallery. Gallery-NG is a pleasure to use, it's simpler to hack, easier to maintain, etc.
    Where do you see the project in 2 years?
    Despite being such a great product, will there still be a market for Gallery?

    I find myself recommending Flickr, picasaweb and other photo hosting services to people that just want to share their images and don't have any technical background. Even with neat auto installers, even an easy to install web application requires maintenance (upgrades) and it requires more technical knowledge to create a webhosting account than to create a Flickr account.

    Gallery (1) was once the best and easiest way to share your photos on the web. That was at a time before there were social networks and photo sharingwebsites.
    Things have changed and the target audience for self hosted web applications is much smaller today. Is it smaller in absolute numbers? I don't know.

    And for people who prefer having their own website but don't want to deal with all the maintenance, there are thin solutions that let you present your Flickr / picasaweb photo albums on your own website.

    So who is still interested in Gallery? What's the audience we want to target this simplified Gallery application for?

    Your mom? No, she'd be a user of a photo hosting service. Well, unless you're the maintainer of that service, based on Gallery-NG.

    It's about people who enjoy freedom. Freedom not to be limited by the design or feature limitations of a photo service. Freedom to post any kind of photo / video without worrying that the service cancels your account or deletes your photos without notice.

    It's about people who would like to build their own website and may even have fun doing the occasional upgrades and discovering new features and improvements.

    It's about people who host their own (small?) community website. Integration features are key in this segment. Scalability as well.

    Right but I don't completely agree ... to me, Gallery is not a tool to share pictures with friend (well, it has been done for that at the beginning and is still a very good tool for that).
    Gallery to me is a great and very flexible tool to integrate a media library in an IT infrastructure.
    That's why I chose Gallery (and why we began modifying it) in my last job and that's why I still choose it now in my new company.
    The idea is to build a media library based on G2 with improved media indexation, semantic search and many other features.
    Gallery is great for that task because it has many interfaces for many purposes such as Gallery Remote protocol, XML-RPC, web frontend, many upload possibilities, open sources, ...
    This the niche where Gallery has a chance : beeing the ultimate Open Source socultion for digital media management.
    There are virtually no project of that kind in Open Source or Free Software while there are a few major commercial products for that purpose (Portfolio, Adobe Lightroom, MS Expression Media, ...)
    Gallery could become a real competitor for those kind of products, especially if we add it some "never seen before" features such as content indexation based on filters (ROC, histograms, images signatures, automatic recognition of forms or phonems, .... there are virtually an infinity of possibilities that could be implemented as plugins).
    Anyway, I don't know which road Gallery is going to take but we will definitely move it in that direction in my company for our usage.


    The bulk of the market is using social websites and photo sharing services.
    It's a niche. But an important niche.

    <sidenote>
    As a sidenote, I see G2 as a special purpose CMS, or application specific CMS. It's got most of the infrastructure to be a step away from a really nice CMS, but it never made that step. It didn't because it's too complex to attract a larger developer community to thrive a diversification into other markets.
    So this Gallery-NG will probably be farther away from being a CMS. It would be simpler, even more application specific.
    </sidenote>

    So, that's what's left of the market after taking social websites and photo sharing services into account.
    What about general purpose content management systems (CMS)?
    CMS are growing into Gallery's market as well.

    Although we invested quite a lot of effort into designing G2 for integration, we are very far from doing an excellent job in this regard.
    Mostly because integration is too complex. I can take the bulk of the blame for that, yay!
    And Gallery didn't provide the more modern means to integrate (RSS, RESTful APIs, etc.).

    When talking about integration, there are basically two markets:
    - Integration into mostly static websites, mostly for presentation (displaying an album, or a slideshow on some website).
    - Tight integration with a CMS assuming responsibilities for all matters related to photo (or even media) management.

    As I said ... don't forget professionnals and companies which need a flexible tool when they have to manipulate huge volume of media data.
    As an example, in my former company, we used G2 to manage around 1 TB of pictures and when I left, we were beginning to have a huge amount of videos too but G2 is, for instance at least, not designed to manage video media at all.

    To me, Gallery is definitely THE tool for companies, professionals or just "super users" to centralize their media management : one input, many output..
    As an example, you could have yoour whole picture library stored in Gallery and then, connect Gallery to many interfaces : it's own web frontend, a rich client, a blog, another server dedicated to post management, source for publish softwares in the publication process, ... you can imagine dozen more usages.





    ---
    LEZARD VISUEL
    Walid Moghrabi - Directeur associé

    www : http://www.lezard-visuel.com
    e-mail : walid.moghrabi@le...
    tel : +33 (0) 9 8008 4932
    fax : +33 (0) 9 8008 4931
    mob : +33 (0) 6 8464 1827 -------------------------------------------------------------------------
    This SF.Net email is sponsored by the Moblin Your Move Developer's
    challenge
    Build the coolest Linux based applications with Moblin SDK & win great
    prizes
    Grand prize is a trip for two to an Open Source event anywhere in the world
    http://moblin-contest.org/redirect.php?banner_id=100&url=/__[ g a l l e r y - d e v e l ]_________________________

    [ list info/archive --> http://gallery.sf.net/lists.php ]
    [ gallery info/FAQ/download --> http://gallery.sf.net ]

    From: Gaynor McCartney <gaynormcc@xt...> - 2008-08-10 17:23

    Attachments: Message as HTML     
    Hi
    checking something else today I discovered things such as the PG theme that I had not managed to find yesterday.
    Odd and interesting that. I was looking in the same place.
    makes me wonder... should such things as modules, themes, colorpacks etc be listed alphabetically which would make it easier to find them... but then would it be alphabetical in other languages? Could the tables be sorted (by some tech magic) to be alphabetical in whatever language they are being viewed in?


    Within the colorpacks table I noticed my Uselect pack, and decided to check the link.
    The current link http://piopionz.com/gallery2/main.php goes to the main page of my gallery where one must scroll down to see the Uselect folder .
    Is it possible to change that link to go directly to the Uselect folder please?

    http://piopionz.com/gallery2/main.php?g2_itemId=4273&g2_enterAlbum=1


    Gaynor

    From: Alec Myers <alec@al...> - 2008-08-13 13:16
    A few thoughts on nice-to-have features for GalleryNG. These aren't
    necessarily original, but they're the ones that stick in my head the most.

    -Have the module name and title included only once (preferably as the folder
    or file title).This will make hacking your own modules much easier to start,
    as you can copy an existing module, change the name, and away you go.
    Currently you have to edit nearly every single class and template file to do
    that.

    -Have module database schemas included in the module resources without
    having to recompile with makefiles, and without having manually to create
    schema update files. Its sufficient just to list the 1.0 schema then then
    the changes for subsequent revisions, and have the Gallery core build sql
    statements to add tables and columns on the fly whenever necessary. For
    people who aren't long-term hackers, setting up GNUMake on their (mostly
    Windows) systems is a pain, as is copying schema changes from, for instance,
    Maps.xml to a schema update file trying to keep everything consistent.

    -Serve public files by storing them in a web-accessible directory and
    directing apache to serve them directly. (I know this has been
    discussed/considered a lot but it's on my desirable list, so I'm mentioning
    it.)

    - Have a module generator wizard that asks some basic questions ("do you
    want an admin page?" "Do you want an editItem page?" "what's the name of the
    module? "do you want to register new permissions?") then churns out the
    basic code structure. Obviously these *partcular* questions might not be
    relevant to GalleryNG.)

    - Allow "lightweight" albums whose contents are scanned live from a
    directory listing. Obviously there are performance implications otherwise
    there'd be no need for a database at all, but for very dynamic albums whose
    contents are changing often it would be convenient.
    Additionally/alternatively, allow gallery to refresh an album by scanning
    the album directory and importing/deleting according to what's in the
    directory.

    - An automatic tasks system/module that could use something like cron to
    schedule housekeeping (maybe including re-scanning directories as in the
    previous suggestion.)

    - A cache directory that doesn't grow without bounds. Permit entities to
    declare themselves as not worth caching, or weed old cache entries.

    - make permissions and settings cascade down the album hierarchy (eg.
    whether to watermark or not) which means you need both allow and deny
    permissions. I understand that the permissions system is possibly
    slow/complicated and might be in line for a radical pruning, but to my eyes
    the current system is just unwieldy to work around, not necessarily too
    complicated.

    - I really like the event system in G2 - I hope that stays. It appears to be
    very lightweight if you don't use it, but can be very powerful. Nested
    events seem to work well too.

    - module dependencies. I know you can sort-of do this with interfaces but
    it's a bit clunky, perhaps. Can it be simpler?

    I'll send more if/when I think of anything.

    -Alec