I would like to offer an existing project to Apache

[Dean Roddey <dr...@charmedquark.com>]

I know that this propsal will likely be difficult to digest, because it has
huge potential but also would likely involve some heartache. But, I will put
it forward nonetheless. It's difficult to fully sum up, so I'll just give
the big picture here and see if anyone is interested in more information.

 

Back in the early 90s I began work on a general purpose C++ framework. This
work continued very consistently up through the early 00's. At that point,
when the internet bubble burst, I decided to go out out on my own. Since
then I have gone on to expand it massively and build a huge automation
system on top of it, though the two code bases are completely separate. At
this point the whole project comes in at just under 800,000 lines of code.
This is proven, in the field type code in a very complex, multi-user,
network distributed product. So 800K really high quality lines of code. 

 

It is kind of a complete soup to nuts world unto itself, starting with an
operating system abstraction layer on the bottom, outside of which no
language or OS headers appear, so everything is built on to of it purely in
terms of it's own interfaces. So the non-GUI parts at least should be quite
portable. I work on WIndows but at one time the back end was running on
Linux, purely through recompilation, no conditional code. That platform
driver code is still there though out of date now. The GUI stuff is also
completely encapsulated, but of course that doesn't mean it's necessarily
easily portable.

 

Still, even if it were only the back end, that would include a vast amount
of highly integrated functionality that really everything in the Apache
world could ultimately be built on, and which would provide a hugely
powerful platform for those folks using Apache systems could build on
subsequently as well. Just to give a brief listing of some of what the
general purpose part provides:

 

1. Full platform abstraction

2. Loadable resource system with resource definition language and compiler

3.  All the usual core stuff, strings, memory buffers, bit sets,
collections, streams, files, file system, system information, mutexes,
events, semaphores, threads, processes, etc...

4. Text transcoding framework

5. XML parser (I wrote the original Xerces C++, and this is sort of based on
that, but fully integrated into a powerful OO framework so much nicer,
though not as far along as yours.)

6. Graphics file format framework, currently with just PNG, JPEG, and BMP,
but easily expandable to others.

7. All the usual socket oriented stuff and serial port stuff

8. An ORB with XML based IDL language and IDL compiler. It's based on the
streaming system, so it's very similar to Java RPC type stuff, i.e. very
little code generated. 

9. Based on the ORB are standard Name, Logging and Configuration servers

10. Image processing

11. CD ripping and audio file format support

12. Metadata management

13. Basic math libraries and some more advanced stuff built on top of that
(e.g. vectors, matrices, etc...)

14. A very nice test framework for doing automated unit and regression tests
and generating reports. It runs each test in a separate process, for
stability.

15. Support for HTML and SMTP. This is a little basic now but easily beefed
up.

16. A simple object oriented data base engine for program configuration and
such

17. An ODBC wrapper

18. Regular expression engine. Just supports simple expressions now, but
could easily be expanded to include more complex expressions.

19. A ZLib compression implementation

20. A virtual machine based object oriented macro language with compiler,
virtual machine and graphical IDE, all embeddable for easy use within apps.

21. A cryptography framework, with current support for Blowfish, MD5, AES,
and SHA1, plus unique id generation. Easily expanded to include other
algorithms.

22. An application shell engine for managing other programs.

21. You may not want to use it, but it has it's own build tool with project
definition language.

22. Color space conversion type stuff.

23. A powerful logging system, which can be easily configured to log to the
ORB based log server if you want, or to local binary or text files, shared
between multiple apps if desired. 

24. A general stats maintenance and access system so apps can maintain
various status and they can be gotten to in a standard sort of way,
including remotely.

 

On the GUI side

22. Wrappers around some basic window types, frame and menu, and all of the
core windowing framework that everything else is built on.

23. Custom implementations of all the other window types, based on the
above, so they are fully integrated into the system.

24. Stuff like file open dialogs, palette dialogs, calendar, etc... various
common dialog types.

25. Wrapper around the web browser control

26. Extension of the loadable resource system for graphics type resources

 

 

Anyway, there's a lot of stuff. A good bit more than I could cover above.
But that should give you some idea of it. And that doesn't include the
automation system that is built on top of it. Keep in mind that, with just a
few small exceptions, everything is a custom implementation, built in terms
of this framework, so that they will be portable. The exceptions are the
JPEG stuff, which uses a bit of the publically available JPEG library, the
WMA codec stuff, temporarily the MP3 metadata stuff which currently uses a
Windows SDK but that could be replaced. 

 

 

The reason I'm doing this is because, for various reasons having nothing to
do with technical excellence, my automation product is not going to be
successful in the professional install world it needs to in order to be a
viable company. So, I'm going to be be in need of employment and I promised
I would open source the product if I even had to give it up. So this might
be a way of doing both. If Apache is interested in the extremely powerful
automation product, that would sort of come for free since it's built on top
of the above framework. It is as large as the general purpose code base. You
can see it at www.charmedquark.com. 

 

So, there it is. I know that's a lot to digest. And, even if you accepted
it, there would be a LOT of politics in terms of really getting the best use
of it, which really involve using it as the basis for other Apache products.
The level of integration it could provide would be massive. It's someting
that really hasn't existed for the C++ world. I know that there have been
some libraries out there. But I don't think really anything like this, where
it was built by a single person with almost no commercial pressures for most
of its life. So it has a level of quality and consistency that you wouldn't
like find elsewhere. And also because almost none of it is just a wrapper
around some black box of code. So almost everything single thing is
debuggable and should be portable (other than noted above.)

 

If there's any interest let me know.

 

------------------------

Dean Roddey

Chairman/CTO 

Charmed Quark Systems, Ltd

 <http://www.charmedquark.com> www.charmedquark.com