David Abrahams wrote:
This category also suggests that anything you haven't put there is somehow less sophisticated.
I tried to differentiate between the groups without making either the more traditional methods sound inferior or the newer ones sound too experimental. Sounds like I failed on both counts.
The whole idea of a "simple/advanced/cutting-edge" hierarchy doesn't seem to work, to me. I'm looking at Boost.Random in the simple category, for example. From my point of view, understanding what that library provides requires a deep understanding of numerical issues that's out of reach for most programmers.
True, but looking at random_demo.cpp, I see that I can put Random to good use without knowing any of that. This is in contrast to things like call_traits and enable_if which aren't much use to anyone unfamiliar with generic programming. My goal was to separate out those sorts of libraries, so people could browse just the ones that might be of interest to them. Unfortunately, that runs into the the same problem as above: how to do that without creating an artificial inferior/suporior or practical/experimental dichotomy between them. [snip}
The intent of the page is to encourage people to explore the Boost libraries. I tried to create categories that would appeal to various interests and ability levels
Good idea; the execution isn't there yet, though.
and that would give a broad overview of the sorts of things Boost has to offer.
Also good. If you list all the libraries you can't help but do that :)
The current library list proves that isn't necessarily true. :) Names like "any" don't mean much to newbies, and while some of the descriptions are fine, others are no more helpful than the names. Even more that good categorization, better descriptions would help a lot in making Boost more accessable to new users. [snip}
Okay, let me take a shot at this. The category I'm least sure about is "system-level." It feels right, but I can't justify it.
I agree. It seems like a natural grouping somehow, but it's a little hard to describe exactly what all those libraries have in common. The first 5 are similar in that they're all clear-cut choices. Most of the time, you'd know whether you had any use for program options, date-time, filesystem, threads, or serialization just by looking at your client specs. The decision to use signals, pool, or Python isn't quite so obvious, but they're also pretty basic design decisions. This is an attempt to fit everything
into a single category, unlike Boost's current list. I don't feel as though any of the library is being badly shortchanged or pigeonholed, but others may disagree. I copied the libs from Beth's list, but it seems short; Beth, are you sure you didn't miss anything?
Something may have gotten lost in the shuffle, but that's most of them. The list may look short because I took out the listings for individual math functions. I figured that for someone interested in those sorts of things, the word "math" would be enough to inspire them to look at the library docs themselves. I think this categorization is the best I've seen so far (mine included). I'd like to see no more than 7-8 major categories though, to make the list seem more accessable and browsable. How about if we grouped some of your categories like this:
** Language Enhancements (change the one below to "C++ Core Enhancements")
* Language Enhancements - libraries that make the standard C++ core language easier and safer to use, or extend its capabilities in "language-like" ways. Many relieve common frustrations of programmers with the C++ language.
Datatypes: variant, optional/in-place-factories, tribool, integer
Language extensions: foreach, enable_if, parameter, ref
Safety: conversion, value_initialized, checked_delete,
* Standard Library Enhancements - libraries that make the standard C++ library easier and safer to use or extend its capabilities in evolutionary ways. Many relieve frustrations commonly encountered when using the standard library (see also Functional Programming)
IO: io state saver, iostreams, format
Containers/data structures: assign, pointer container, array, bitset, multi_index, multi-array, tuple
Iterators: iterators, next/prior, range
Algorithms: minmax
** Program Development Utilities
* Class definition utilities
operators, noncopyable, base_from_member, compressed_pair
* Type information, synthesis, and computation
Type Traits, Call Traits, MPL
* Functional Programming - libraries for working with functions and function objects. Especially useful in conjunction with STL algorithms, but any program can benefit from functional programming idioms.
lambda (see also bind), bind/mem_fn (see also lambda), functional (deprecated), function
** Text and Number Handling - These range from enhancements to improve accuracy and performance to full-featured libraries suitable for advanced text and mathematical processing.
* Numerics, number crunching, high-performance computing.
CRC, functional/hash, random, rational, graph/property map, interval, math, ublas
* Parsing and Text Processing
Regex, XPressive, Spirit, tokenizer, string_algo
(The rest stay as they are)
* System-level libraries
Program options, date-time, filesystem, threads, serialization, signals, pool, Python
* Testing and debugging
timer, static_assert (see also MPL assert), concept check, test,
* Code Generation
Preprocessor, wave
* Portability
compatibility, config