Grant Proposal: Ado - a rapid active commotion (framework for web-projects on Mojolicious)
Fri, 16-Jan-2015 by
Makoto Nozaki
edit post
The Grants Committee has received one grant proposal for the January round. Before the Committee members vote, we would like to solicit feedback from the Perl community on the proposal.
Review the proposal below and please comment here by January 25th, 2015. The Committee members will start the voting process following that and the conclusion will be announced by January 31st.
**Ado - a rapid active commotion (framework for web-projects on Mojolicious)**
- Name:
Krasimir Berov
- Amount Requested:
USD 4500
## Synopsis
[Ado](https://metacpan.org/pod/Ado) is a _light on dependencies_ application and framework for web
projects based on [Mojolicious](https://metacpan.org/pod/Mojolicious). With this project Ado will provide an
__easy to start with__ Content Management System that can scale from a
personal blog to an ERP, CRM or any custom application for managing the
enterprise, by just adding plugins (modules).
PHP has plenty of CMSs which are easy to install and run on cheap shared
hosts. This is an almost empty niche in the Perl world. We do not have
popular, easy to install by beginners, CMS. Ado aims to fill this gap.
## Benefits to the Perl Community
[Ado](https://metacpan.org/pod/Ado) is already on CPAN. It consists of an application class (the core),
several modules (controllers, model classes, plugins) and templates.
[Ado::Plugin::Vest](https://metacpan.org/pod/Ado::Plugin::Vest) is also on CPAN. For a Perl developer CPAN-like
systems are the preferred way of managing dependencies and reusing code.
Ado is [Stratopan](https://stratopan.com/),
[CPAN::Site](https://metacpan.org/pod/distribution/CPAN-Site/bin/cpansite),
etc. ready. But PHP developers and/or beginners expect to download a
package, unpack it and have a running themeable site (e.g. Drupal, Joomla,
WordPress ...).
- In my private projects I almost always stumble upon clients which
want (or they think they want) Just a Site With Several Pages ASAP. Then it
turns out they want to be able to edit the pages, post some news, make a
catalog of the products/services they offer. We end up with installing
some of the popular CMSs on a cheap shared hosting provider. Then the
customer decides she needs some custom functionality. I end up writing
custom modules or modifying existing ones for the respective CMS in PHP.
_This project will allow many Perl developers to do the same in Perl._
Much more pleasure and fun!
Let us enter the _Cheap Sites For The Small Business_ niche. Start small,
quickly and easily and grow with your customer (staying with Perl)!
- Several modules which will be put together with the core
application in a package for easy installation of a CMS which will just
work (Getting started in 5 minutes). The modules (plugins) will be
available on CPAN too so an advanced developer/site-owner can install just
the core and add whatever he/she needs later. Ado follows the Mojo
principle of loosely coupled components, still it will provide a
ready-to-use beginner's' package.
- Make it easier for beginners to start digging and adding their own
custom modules or just modifying the installed system. They will
immediately see the results of their changes in an otherwise complex and
enterprise-ready system.
- A wider audience will be given easier access to the world of
(modern but simple (no magic)) Perl 5. Later when they feel more familiar
with how the things work together, they will start using CPAN to distribute
their Ado plugins and find more modules on CPAN.
- Users (and developers) of Ado will get more familiar with
Mojolicious which in turn will make Mojolicious more popular, which in turn
will make Perl 5 more popular.
- The project is valuable also for more advanced audience as it
provides a framework for rapid application development on top of
[Mojolicious](https://metacpan.org/pod/Mojolicious) for full featured and complex MVC applications.
- One of the purposes of the Mojo project was to enable Perl
developers to build their own frameworks. Ado is such a framework. It can
be a good example, a trigger for other such frameworks to appear. It will
ease starting of new custom projects based on and around it (and
Mojolicious).
- Ado already serves as a more complex example application built on
top of Mojolicious. People report they use it by copying and pasting
snippets of code in their own Mojo apps :). But Ado can be used the proper
way - by extending it and by using Mojolicious and Ado plugins.
- [Ado::Build](https://metacpan.org/pod/Ado::Build) extends
[Module::Build](https://metacpan.org/pod/Module::Build). It is a more advanced example on how Module::Build can be
used to implement flexible installations of Perl applications and complex
build and deployment scenarios.
- Ado uses [Test::Perl::Critic](https://metacpan.org/pod/Test::Perl::Critic) to restrict the TIMTOWTDI symptom
and impose a unified coding style. When a complex system is implemented,
there should be
an agreement on ways to do things. We use a slightly relaxed mode of the
"harsh" severity. With the usage of new actions like `./Build perltidy` in
[Module::Build](https://metacpan.org/pod/Module::Build) and restricting the ways the code is written
(Test::Perl::Critic), we show a good example of how big, enterprise-ready
applications can be build using Perl by many developers around the world,
working together.
- In the documentation and on the demo site it will be clearly stated
that the project is sponsored by the Perl Foundation. Users and developers
will be encouraged to express their gratitude by donating back to the Perl
Foundation if they want to support this and other future projects.
## Deliverables
### Installation package (tarball/zip).
The package will consist of preinstalled Ado with several plugins and
prerequisites (Pure Perl only) which can be just unpacked in a
`DocumentRoot` folder of an Apache 2 with mod\_fcgid/mod\_cgi shared host or
run using hypnotoad.
### Task::Ado::Site - All modules required to run a site based on Ado.
This module will be available on CPAN. It will only depend on modules
needed to run a minimal Ado site. It will be used to prepare the
"preinstalled" package (see above). It will also serve as an example of
making other Task::Ado::Xyz bundles. This will be the preferred method to
start a site directly from CPAN.
### [Ado::Plugin::Admin](https://metacpan.org/pod/Ado::Plugin::Admin) - system (site) administration user interface.
This plugin will provide user interface and API that will be used by Ado
plugins. It will consist of a left(top) panel in which the plugins will add
links (menu items) to their routes and a main area. The default content for
the main area will be a dashboard with short description of every installed
plugin
(provided by the plugin). This plugin will also provide REST API so the
user interface can be completely separated from the implementation. Route:
`{route => '/ado', to=> 'ado-default#index'}`.
The plugin will be uploaded to CPAN. Task::Ado::Site will depend on it and
it will be included in the "Installation package". Existing
[Ado::Control::Ado::Default](https://metacpan.org/pod/Ado::Control::Ado::Default) will be moved to this plugin.
### Ado::Control::Ado::Users - Manage users
There is already a stub implementation of this controller. It will provide
CRUD implementation with REST API and templates.
[Ado::Model::Users](https://metacpan.org/pod/Ado::Model::Users) is already implemented and covered with tests. This
functionality will be moved to [Ado::Plugin::Admin](https://metacpan.org/pod/Ado::Plugin::Admin).
### [Ado::Plugin::Site](https://metacpan.org/pod/Ado::Plugin::Site) -Render and manage pages
This plugin will consist of CRUD implementation with REST API and templates
for managing pages in the admin area and corresponding implementation for
rendering pages in the site area. The plugin will be uploaded to CPAN.
Task::Ado::Site will depend on it and it will be included in the
"Installation package".
The initial code will be generated using
[Ado::Command::generate::adoplugin](https://metacpan.org/pod/Ado::Command::generate::adoplugin).
### Ado::Plugin::Signup - local user registration
Ado already provides [Ado::Plugin::Auth](https://metacpan.org/pod/Ado::Plugin::Auth). Currently we support sign-in via
Google, Facebook and locally. Ado::Plugin::Signup will allow a user to
register locally. The plugin will be uploaded to CPAN. Task::Ado::Site will
depend on it and it will be included in the "Installation package".
The initial code will be generated using
[Ado::Command::generate::adoplugin](https://metacpan.org/pod/Ado::Command::generate::adoplugin).
### Ado::Plugin::I18n - Internationalization and localization for Ado
This module is already implemented and part of Ado (core).
Implement loading of translation entries from the database and CRUD
interface (UI and REST) for managing translation entries in the admin area.
### Ado::Plugin::Vest - Messaging services for an Ado system!
[Ado::Plugin::Vest](https://metacpan.org/pod/Ado::Plugin::Vest) is already on CPAN. It implements a (not too) naive
messaging service for any web-application based on [Ado](https://metacpan.org/pod/Ado). It can be used
as a chat between two users, as commenting widget under articles, for
showing system messages etc. Currently a HTTP based chat application is
being implemented as a proof of concept. Private messaging services are
becoming a mandatory feature for the enterprise.
As part of this project I will add a group chat functionality (rooms).
### Ado::Plugin::Blog - a blog for your site
Ado::Plugin::Blog is not yet implemented. It will consist of frontend
functionality for rendering articles in the site area and an administration
part (CRUD) for managing articles.
The initial code will be generated using
[Ado::Command::generate::adoplugin](https://metacpan.org/pod/Ado::Command::generate::adoplugin).
### Cleanup...
...and update the existing already code and documentation. This involves
removing unused templates and code, reviewing and improving existing code
and documentation. This task will continue throughout the project.
## Project Details
Ado is a framework for web projects based on Mojolicious, written in the
Perl programming language. Its development was started in November 2013 as
a rewrite of a previous project
([MYDLjE](https://github.com/kberov/MYDLjE#___top)) based on Mojolicious
1.9x. MYDLjE was too monolithic. It was not possible to start with minimum
features, disable some of them and re-enable them only if needed. Ado is
much more modular and flexible than MYDLjE and its name is not an acronym
:).
Ado is a typical well structured, MVC Mojolicious application. It comes
with default configuration and a model layer, plugged in by
Mojolicious::Plugin::DSC. An SQLite database is bundled in the distribution
at etc/ado.sqlite to get started quickly.
Ado provides additional plugins and commands, which promote RAD, good
practices, and team-work when starting new projects. The default Ado page
uses Semantic UI CSS and JavaScript framework via
Mojolicious::Plugin::SemanticUI and is a good place to get acquainted
with the system.
Ado is already on [CPAN, where you can find detailed
description](https://metacpan.org/pod/Ado::Manual). Currently supported
installation methods are also described
[in the documentation](https://metacpan.org/pod/Ado::Manual::Installation).
Ado plugins system is a super-set of the Mojolicious one. The most important
feature of Ado plugins is that they can use their own configuration files
(separation of concerns). More details can be found in
[the documentation](https://metacpan.org/pod/Ado::Manual::Plugins).
The framework is fully functional (for sure there are bugs). It was
presented at YAPC::Europe 2014. Here are the video and presentation -
[https://www.youtube.com/watch?v=8kBOxd6DQsM](https://www.youtube.com/watch?v=8kBOxd6DQsM),
[http://www.slideshare.net/kberov/ado-yapceu2014](http://www.slideshare.net/kberov/ado-yapceu2014). The code is well
covered with tests. My target test coverage will be 85% in total.
This project is about making the "application" part of the framework and
delivering a ready-to-use application much like popular CMSs. Everything
implemented so far is done by the author (me) with the help of some friends
from time to time. The development progress can be tracked on
[Github](https://github.com/kberov/Ado).
## Inch-stones
Below is once again the project divided by tasks. Each task consists of one
or more inch-stones. When all listed tasks are done, the project can be
considered completed. In the course of the project some tasks may require
to be done simultaneously. The order of the tasks matters. All these will
be tracked in Github as issues of the respective repositories. Writing
tests and overall QA are not explicitly mentioned but are assumed.Targeted
test coverage of the code is 85% in total. Each module will have
[Test::Perl::Critic](https://metacpan.org/pod/Test::Perl::Critic) tests
([example](https://github.com/kberov/Ado/blob/master/t/perl-critic.t)).
Each task is considered done when the respective module is uploaded to CPAN
and there are no test failures reported from [http://cpantesters.org](http://cpantesters.org).
### [Ado::Plugin::Admin](https://metacpan.org/pod/Ado::Plugin::Admin) - system (site) administration user interface.
This task is a prerequisite for most of the other tasks and for any future
plugins that will provide any UI in the administration area.
- Create https://github.com/kberov/Ado-Plugin-Admin repository;
- Generate the initial code;
- Implement the initial API that will be used by other plugins to
display UI in the admin area;
- Implement the REST API so the default UI can be totally replaced by
a client side application (AngularJS, EmberJS, GTK+ etc);
- Implement the templates and default client-side UI. The UI will be
completely usable, based on Semantic UI;
- Implement Ado::Control::Ado::Users and UI.
### [Ado::Plugin::Site](https://metacpan.org/pod/Ado::Plugin::Site) - Render and manage pages
The completion of this task can be considered an important milestone. With
this plugin one will be able to create a basic site.
- Create https://github.com/kberov/Ado-Plugin-Site repository;
- Generate the initial code;
- Implement the controllers, model classes and REST API both for the
admin and site areas so the default UI can be totally replaced by a client
side application (AngularJS, EmberJS, GTK+ etc);
- Implement the templates and default client-side UI for the admin
area. The UI will be completely usable, based on Semantic UI;
- Create some pages: Home, About us, Mission
### Ado::Plugin::Signup - local user registration
Generally this plugin will be used less as we already provide "Sign in" via
popular social platforms with Ado::Plugin::Auth which uses
Mojolicious::Plugin::Oauth2.
- Design the workflow;
1\. User enters "email", "login\_name","first\_name","last\_name" and submits
the form; 2. User receives a temporary password via email; 3. User changes
his/her password. In this case HTTPS connection is mandatory...
- Implement REST API and UI templates for the process.
- Ado::Model::Users is already implemented but still may require some
enhancements or fixes.
### Ado::Plugin::I18n - Internationalization and localization for Ado
- Implement the controllers, model classes and REST API for the admin
for managing translation entries stored in the database. This way the UI
for an Ado based site can be easily localized into many languages by
non-programmers. The default UI can be totally replaced by a client-side
application (AngularJS, EmberJS, GTK+ etc);
- Implement the templates and default client-side UI for the admin
area. The UI will be completely usable, based on Semantic UI;
### Ado::Plugin::Vest - Messaging services for an Ado system!
Combined with the OAuth2 authentication support in Ado this plugin can be a
good foundation for a community or intranet site. Any Google+ or Facebook
user can authenticate and use it for instant messaging.
This task is to add group chat functionality.
- Implement the actions (REST API) for creating a new group (room).
- Implement the actions (REST API) for adding users("friends") to the
group.
- Implement the templates and default client-side UI under /vest/\*
route. The UI will be completely usable, based on Semantic UI;
### Ado::Plugin::Blog - a blog for your site
Completion of this task will be the second important mile-stone. With it we
practically can react quickly to 90% of customer requests.
- Create https://github.com/kberov/Mojolicious-Plugin-TinyMCE
repository;
- Implement Mojolicious::Plugin::TinyMCE which will provide a helper:
Rich Text Editing functionality for textareas;
- Integrate [Tiny MCE](http://www.tinymce.com/); Experiment and
decide if to embed the Tiny MCE code into Mojolicious::Plugin::TinyMCE.
- Create https://github.com/kberov/Ado-Plugin-Blog repository;
- Generate the initial code;
- Implement the controllers, model classes and REST API both for the
admin and site areas so the default UI can be totally replaced by a client
side application (AngularJS, EmberJS, GTK+ etc);
- Implement the templates and default client-side UI for the admin
area . The UI will be completely usable, based on Semantic UI;
- Add "Comments" functionality using Ado::Plugin::Vest REST API;
- Create an article: "How to write articles?"
### Task::Ado::Site - All modules required to run a site based on Ado.
- Create https://github.com/kberov/Task-Ado-Site repository;
- Prepare the module, Identify and list the dependencies.
- Experiment with it and prepare the Installation Package.
- Research and find the best way to automate the generation of the
Installation Package and uploading to Github.
- Create Github page for Ado and add a download link to the latest
package;
- Add a "Getting Started " page (tutorial) for beginners and non
Perl developers.
### Cleanups, fixes and improvements to Ado...
As already mentioned this task is continuous and consists mainly of small
changes in the Ado distribution it self.
It will continue during the whole project.
## Project Schedule
Each task should take up to one month as I work full time and I can spend
up to 16 hours per week.
Some tasks may go simultaneously or overlap (e.g. Admin and Site plugins).
As they are divided in inch-stones they are still easily tracked. The
common time of this project is estimated to up to 6-7 months. I can start
immediately. In fact I will jut continue with the natural evolution of Ado.
I count on the community for feedback, proposals and why not code if
they feel they have something better in mind during implementation. See
[Ado::Manual::Contributing](https://metacpan.org/pod/distribution/Ado/lib/Ado/Manual/Contributing.pod)
## Completeness Criteria
As mentioned already in the Inch-stones section, all modules will be
released to CPAN. The code should be covered with tests 85% or more. The
Installation package, produced by Task::Ado::Site, will be available for
download from the Github page of the project. A demo site will be available
for manual verification of the promised features.
## Bio
I am self-taught, pro-Perl-y thinking software developer, engineer and
author with over 13 years of experience in creating applications for the
web with database back-end. Learning from the real life and always with an
eye in the tech-books.
Well aware and picky about everyday emerging buzzwords. Able to recognize
new technologies which come to stay.
My specialties are : Perl, Web, SQL, JavaScript, Linux, web-applications,
Web-Crawlers/Spiders, I18N/L10N, CMS, on-line payments...
I contributed to some CPAN modules (https://metacpan.org/search?q=BEROV)
and in different ways to several bigger open source projects like TWiki,
Contao and most recently Atom.
I am Bulgrarian currently living and working in Prague, the Czech Republic.
Comments (17)
Long time perl-against-dbd-pg guy. It is my humble opinion that mojolicious could be a big help in bringing more coders back to perl, or to take the plunge with perl.
Mojolicious should make sense to nodejs programmers in particular, and I think this project would be a nice entry for many.
Personally, it was a framework on top of a framework that served as the terrain for my long relationship with perl. The Bricolage framework was written against HTML::Mason, mod_perl and DBI, and gave me a lot of structure and solid practices to copy. Cheers to David Wheeler for that.
If this project is done with the same quality it could help many people grasp and use mojolicious quickly and (hopefully) thoughtfully.
To elaborate a bit.
Ado ensures high quality by using Test::Perl::Critic in development mode as optional dependency. This way we will impose a uniform coding style and will avoid bugs. This was mentioned in the project description already.
Here is how I propose to do that: (https://github.com/kberov/Ado/wiki/Devnotes). This is how I do it at least. This applies for all sub-tasks(e.g. Ado::Plugin::Admin, Ado::Plugin::Site etc.).
For sure I am open for feedback and advices from gurus. It is impossible for someone alone to do it all and with high quality. At least some discussion must take place. And this is the way for anybody wishing to influence the project. Till now I tried to read, understand and apply what I already was seeing in Mojolicious.
Please, in the respective projects' repositories in Github (to be created), use the "Issues" form to express your wishes and constructive criticism.
Still for the sake of making this project happen on time and within the budged, let's restraint our self to the deliverables described above, i.e. no additional features please, unless they happen to prove as being "must-have".
As a web developer and perl lover for so many years, I'm glad to see Ado here.
I have written so much pseudo frameworks (framework is a big word here) on my own, depending on what each project needs. I've used mod_perl and catalyst so many times. Lately I'm using Mojo.
I really grew tired of starting all over again for each new project. Surely I've reused some old code, but I was dreaming for the moment when I will be able to write my own framework which will give me the following:
1. Fast and easy deployment with basic functionality informational site (kinda static site)
2. Integrated user management.
3. Integrated Admin Panel.
4. Easy way to extend the project with extra functionality (eg. gallery, forum, etc.). I was thinking of modules made as plugins (what else...). Every plugin should introduce it's stuff into the admin panel too.
5. Write many plugins.
Basically something similar to most PHP CMS systems, but written in Perl, hence better than every PHP CMS.
Then... at some point in the time, I've found Ado.
I was so happy while reading it's documentation... I was thinking: finally, someone did it, I can just join this project, instead of writing it from scratch.
I really like that Ado is based on Mojo, or more like it extends Mojo in it's own way.
Thanks to Mr.Berov, we now have a good base for CMS based on Mojo (which is the best option IMO).
I've joined the project some time ago, but still have to commit my ideas.
I'm really exited with Ado.
Give it a try and you'll like it too. ;)
I second Mike's and Stanislav's comments.
Ado++
Can't comment on the code quality of what is already available as Ado on CPAN, but otherwise
- this proposal is quite detailed => apparently the author was willing to invest some time
- it seems to not re-invent something that's already there (there's the Galileo CMS - https://metacpan.org/pod/Galileo - but Ado seems to aim higher)
- it sounds like the outcome could provide real benefit
- deliverables include docs / tutorials.
Some suggestions:
- break it down to 3 or 4 parts, with partial payments due after the completion of each part.
- add requirement of a "product"/"project" website (running on Ado, of course) to enhance visibility outside CPAN echo chamber
Only caveat: would be nice if some perl people working in this area could provide their insight, if the things proposed above make sense and if it could be beneficial for them in their professional work.
Without any comment on any other aspect of the proposal, I wanted to define exactly what will be delivered to the CPAN.
Currently ado is lgpl-v3. If the Perl foundation did sponsor this would the code be released under the artistic license? Does Krasimer have all the copyright to the existing code in order to offer it under an artistic license?
I am concerned about the listed "benefits to the Perl community" in the proposal. Many of them don't really read as benefits, or at least don't seem like benefits that are unique to Ado.
The premise seems to be that a CMS running on Mojolicious is a good idea. I tend to agree with this. I'd love to see a real competitor to Wordpress emerge in Perl.
But is this the right CMS to back? Will it get the popularity that Wordpress has? Is this the best use of $4,500? Perhaps the answer is yes, but I haven't seen enough information to make that conclusion.
The only thing I see that gives the project any credibility at all is a long standing commit history with multiple contributors: https://github.com/kberov/Ado/graphs/contributors
I would have liked to see the code at least have a project website (maybe running on Ado) with a few links to real sites where it is in use right now. Perhaps testimonies from other devs that are using Ado. Really anything to give Ado more credibility would be persuasive. Before investing the community's contributions, I'd like to see some more assurance that the project we are investing in will have a real future.
There haven´t been many "cool" new projects written in Perl in recent years that gained widespread popularity and established a community. Enthusiastic young programmers seem to lean to other programming languages nowadays.
If Ado could or will "get the popularity that Wordpress has" is unpredictable. If it will even survive for considerable time is equally unknown.
To me, granting this request would/could/should be seen as an investment both in supporting the existing perl community by extending their toolkit and in providing a means for marketing perl to people outside the existing community.
That´s why I also suggested making a project website (running on Ado) a requirement (cf. previous comment).
In comparison to low level libraries and frameworks this has at least a bit more potential for establishing a community and being used to "show off" or brag about.
I share your concerns that having a stronger basis for deciding on this grant request would be good but I´m not sure how that could be achieved.
Maybe the decision on the granting of this request could be postponed until after such a website has been established and showcases some real world use of Ado?
Or maybe the request could be granted but the grant period would start only after the website was published?
@hjansen, Thank you!
- Code quality:
To make sure the code respects some rules Ado has Perl::Critic tests (https://github.com/kberov/Ado/blob/3b60b2ea3bb3aff180fee459b6359ef0ab056761/t/perl-critic.t) with a reasonable severity (https://github.com/kberov/Ado/blob/3b60b2ea3bb3aff180fee459b6359ef0ab056761/t/.perlcriticrc). These tests are run before each release (https://travis-ci.org/kberov/Ado).
- Proposal details:
With the above item I put even more details to it showing that I spent already some time and, yes, I intend so spend some more :).
- Reinventing the wheel and the hot water:
Mojolicious already did it in a better way somehow in the sense of http://en.wikipedia.org/wiki/Wankel_engine .
I just intend to use it to show its qualities to the un-initiated.
- Benefits:
Yes, it is something which after completion, is a complete product - can be used immediately - no programming required.
- Breaking into parts:
Major milestones are good candidates. 1. Ado::Plugin::Site; 2. Ado::Plugin::Blog; 3. Task::Ado::Site and downloadable package produced by it.
- Insights: https://github.com/kberov/Ado/issues is a good place for gurus to put their criticism, insights and concerns.
@Mark Fowler, Thank you!
What will be delivered on CPAN? : Everything will be delivert on CPAN in peaces defined as deliverables except the Installable package which will be available as as tar.gz/zip on the github page of the project
License?: Ado Is LGPL-V3. I started it from scratch. It extends Mojolicious. As far as I understood, any open source license is acceptable. You can use it in your commersial projects.
@Dan Wright, Thank you!
- Benefits: May be I was too wordy. The Idea was to show a case and how it is addressed. I hope that even if removing the unclear ones it still worth it. Most prominent is the end-user product - A package that can be unpacked and used on a cheap shared hosting - bringing newbies.
- Is this the right project to back?:For sure It is an entry point to the world of Perl for half of the calling them self web-programmers. CMS is the answer of the prominent question "How do I do a site in language X?"
- Will it get the popularity that Wordpress has?:Not in the near future. Not without the financing WordPress, or Drupal or Java or MysQL or X has. But I already played Baron Münchhausen (who saves himself from drowning by pulling on his own hair) and it worked.
- Is this the best use of $4,500?: For most people - No. Every startup has inherent uncertainty
https://github.com/kberov/Ado/issues is a good place for interested people to put their criticism, insights and concerns and change that.
- Project website?: A little outdated version is available at http://ado.0xaf.org/ on a mashine provded by Stanislav Lechev. This will improve.
Regards.
Yes, there are already many frameworks, and yes it'd be good to see it running publicly, and yes, etc.
Even so, Mojo is a sophisticated basis for such work, and my preference, and the thoroughness of the work done, and discussed above, suggests that I (at least) can be optimistic of great success in the task of attaining the project's goals.
So - I'd like to see this project get funding.
Sigh - In the old days I could log in here to comment, but no longer. Oh, well.
It's catch 22; The grant would not be needed if there were multiple sites running Ado already.
This came up from discussion within the Grants Committee.
As some people mentioned, there are a number of web frameworks already. What problems specifically is Ado (trying|going) to solve? What makes Ado unique?
Here they are:
Not so much of a framework, rather a ready to use application to quickly bootstrap customizable projects. Think "A Site with Control Panel, users management pages management, blog in 5 minutes!" This will bring immediate income to one-man shops.
Reduce the time needed to have something (working!) to show to the customer from one week to one day. (Reduced time to market) Ado(.pm) +Ado::Plugin is the needed tiny layer for such an application. Task::Ado::Site aims to be much like Django CMS https://www.django-cms.org/ - "easy-to-use and developer-friendly CMS".
I like this project and want to see it get funded. Why? It's cool, it's light and it pretends to give us something more than "Just an another CMS framework from very short list of Perl CMSs".
I know the author and he's real professional, so the final product is guaranteed!
Again, when I say "much like" I mean only "easy-to-use and developer-friendly CMS in Perl" - nothing else.
Here is a UI draft (I made yesterday) of the administration panel dashboard https://github.com/kberov/Ado-Plugin-Admin/issues/4
Put it otherwise - a tiny application on top of Mojolicious for managing customizable web-sites.
Look and feel of the UI will be what I found most intuitive during the years. Of course everybody is encouraged to influence the details of the implementation.
Thanks!
I share the concerns Makoto Nozaki mentioned. I'm not sure the benefit for the perl community is really all that big. The world has plenty of CMSish systems (including some in Perl), just because one more in Perl exists doesn't mean people will switch to using it.
Well, Leon,
(problems that Ado is trying to solve)
1. We will attract those who are biased - growth in Perl expertise and retainment of community members.
2. Anybody generally preferring Perl would use it if it does not give him/her more hurdle than a PHP alternative - retain existing community members.
3. Any web-programmer wanting to try Perl would look for a web app that can be installed easily - new joiners.
(uniqueness)
1. Fresh code leveraging fresh framework. Lack of "historical reasons". Concentrating on application logic leaving the underlying framework to do the tedious job. Separation of concerns.
2. Imposed uniform coding style and best practices. Following paradigms from a popular framework - Mojo. Who knows Mojo can pick up quickly Ado and vice-versa.
3. User and developer friendliness. Reasonable simplicity. Light on dependencies - not requiring half of the CPAN. Ease of code management. advanced usage of Module::Build.