HTML 5 Helper Libraries

We are finding more and more projects that help with HTML 5. Although we're not right now looking into supporting HTML 5 directly, we keep an eye open to new technology, especially if it can help us get a better feel for our sites.

Dynamic CSS (a form of scripting language for CSS content) -- http://sass-lang.com/

CSSTidy (CSS compression/beautifier) -- http://csstidy.sourceforge.net/

A Compass Extension -- http://susy.oddbird.net/

Responsive breakpoints (no idea what that really is though) -- https://github.com/Snugug/Aura

CppCMS

We were thinking of using the CppCMS base library. This library includes all the necessary base code to handle forms, but it makes use of FastCGI which is a CMS in itself so we cannot really make use of that at this point.

ceph

This system is a large number of libraries and Linux modules (kernel level!) which can be used to create fast and efficient file distribution systems.

http://ceph.com/

At some point we may want to switch to ceph instead of using Cassandra to handle all our files. At this time we do have enough anything to test and make sure that ceph would be faster than our existing code using Cassandra. One place wher ceph may win is the ability to send the data directly from the computer that has the data to the client instead of going through the front end as we have to do with our Cassandra implementation.

cTemplate

For the theming we wanted to generate the output with cTemplate. It support tags like syntax that we can offer the user at all levels. For example, a newsletter could use "Hello {{NAME}}," and have the {{NAME}} variable replaced with the name attached to the destination email.

However, XSLT seems to be a much better choice since it can parse XML data automatically and it can be used to output XML, HTML, PDF, Text, RDF, etc. and all of this without the need for a very large amount of work (assuming we can find existing XSLT files that help us with that work.)

FastCGI

The FastCGI is an interesting implementation to quickly create dynamic pages in C++ using a boost like style (it uses boost and all the implementations are very much like boost.) So if you like very advanced C++ coding, this is certainly a good one for you.

ppC++

This precompiler for HTML C++ pages will compile HTML into a .cgi written with embedded C++ code, just like you would embed PHP in your HTML!

http://ppcpp.sourceforge.net/

libcassandra

A very simple C++ library by Posulliv. However, this library forces you to access the thrift structures and does not hide the Cassandra lack of hiearchy (i.e. the cassandra object does everything, it's a hub.)

https://github.com/posulliv/libcassandra

Wt

A C++ environment to create websites. It includes everything from a server to advanced widgets (that we could certainly share since they use the GPL.) However, it feels like this isn't a CMS, instead you have to build your website from scratch each time.

https://www.webtoolkit.eu/wt/

Skia

Skia is a 2D graphics library used by Chrome to render text, pictures, and geometric objects. This library is fully optimized to use OpenGL and other accelerators available on the given server.

https://github.com/olafvdspek/ctemplate

Big Tables

The Cassandra database system is based on a project named Big Tables worked on at Google. (See the attachment called bigtable-osdi06.pdf, it comes from Google, but the page it was available on has disappeared.)

More or less, the big table scheme defines how Cassandra saves and manages the data on disk. All the tables are write once and relatively flat in comparison to standard/conventional database systems. To reduce the footprint of the data, it also compacts the tables. This means a certain number of files are concatenated in one bigger file. This can be achieved because older data is less likely to change over time (actually, data that changes continuously will not be compacted.)

Reading the paper will give you a lot of details. They conducted a test with over 1,700 nodes (not Cassandra, just Big Tables,) and the times to execute writes grew only to a certain point. After that it nearly stabilized itself. Reads were slower as the tables grew, though. However, that was over millions of hits and 1 EB or so of data.