![[Home]](/boost.png)
Google Summer Of Code 2008Google Summer Of Code 2008Tips for the students
Non-students: if you have an interesting idea for a Boost project for GSoC 2008 and you want to give it to the public, please edit this page and write it down! You can copy and paste the template listed as the first entry. Don't forget to update the table of contents, too.
Some Potential Projects:
Previous Years Projects:
Introduction: Compilers such as [GCC 4.3] are starting to include early implementations of C++0x features like variadic templates, rvalue references, decltype, and static_assert that can be used to improve the implementation of Boost components. Using these features, build newer, cleaner versions of these Boost components to make use of C++0x features. Ideally, these versions can be added into Boost and enabled when the compiler provides the right set of C++0x features. (For example: BOOST_STATIC_ASSERT already uses static_assert when it is available in the compiler).
Goal: Identify Boost libraries that can benefit from the use of these C++0x features, re-implement or update those libraries to use C++0x features when they are available, and ensure that the C++0x versions both (a) work on the regression tests meant for the C++03 versions, and (2) provide the improvements one would expect from the C++0x version.
Requirements: Good knowledge of templates and Boost. Willingness to explore the upcoming C++0x standard and its features, and to work with potentially buggy implementations of C++0x features within these compilers.
Note: For those students interested in the implementation of C++0x features in a compiler or their use within the C++0x Standard Library, [GCC will also be a GSoC mentor organization].
Suggested by Douglas Gregor (doug.gregor@gmail.com)
Introduction: The [C++ Networking Library] (cpp-netlib) seeks to adds network protocol support to Boost using [asio]. The initial focus is to add support for HTTP(S) 1.0 and 1.1.
The [Pion Network Library] (pion-net) is a C++ development library for implementing lightweight HTTP interfaces. There are a wide variety of open source HTTP servers available, from fast and lightweight servers such as [lighttpd], to full-featured platforms like [Apache HTTPD]. The motivation of pion-net is not to implement yet another web server, but to provide HTTP(S) functionality to new or existing C++ applications. If you're looking for a full-featured server application, we suggest that you use one of the projects above. If you're working on a Boost C++ application and would just like to use HTTP to provide a simple user interface or interact with run-time data, then pion-net is a much cleaner and simpler solution.
Pion Network Library uses the Boost and [asio] libraries for multi-threading and asynchronous I/O. Multi-threading allows the use of multiple CPUs or processing cores to process HTTP requests simultaneously. Asynchronous I/O allows each thread to handle many connections simultaneously (otherwise, a single thread would be required for every connection to the server). The combination of these technologies takes full advantage of the most modern CPUs, and allows servers implemented using pion-net to handle many thousands of connections simultaneously with a single physical server.
Pion Network Library lets you run multiple servers listening to any number of ports and network devices. Each server may have its own collection of web services defined which are bound to HTTP resources. Protocols other than HTTP can also easily be implemented for any server. A common thread pool is used to handle operations for all servers. pion-net also supports server-side SSL & TLS encryption when built with the [OpenSSL] library.
Goal: This is an active, stable library published under the Boost Software License, and maintained by [Atomic Labs, Inc.] It currently consists of about 15,000 lines of C++ code. We would like to prepare the library for inclusion in Boost. This will require some cleanup of the library for conformance with Boost's standard coding practices, and development of more unit tests and better documentation. We would also like to replace our current plugin implementation with the proposed [Boost.Extension] library (or preferably, add it as a build time option).
** Update: ** As its maintainer, I hope to merge the functionality of the Pion Network Library into [cpp-netlib] and submit the final product for peer review to be included in the next major Boost distribution. With the two projects combining, cpp-netlib is now the definitive candidate for adding network protocol support to Boost.
Requirements: Strong C++ skills including STL and templates. Familiarity with the Boost libraries and best practices. Networking (especially HTTP) experience would be very helpful, but not entirely necessary.
Other sections: I wrote most of the code for the Pion Network Library, and am willing to help mentor this project.
Suggested by Michael Dickey (mike at atomiclabs dot com)
Introduction: Implement 'safe int' class template which supports all C++ arithmetic and boolean operators and will ensure client notification on all failures such as arithmetic overflow and underflow.
Goal: Platform independent code, docs and tests to Boost need to be delivered -- review within SoC? period would be a plus (only if you think it's doable).
Requirements: Basic knowledge of C++ templates and a good understanding of limits of computer computation systems. Extreme ability to focus on details.
Notes: David LeBlanc at Microsoft created something similar a couple years back. See http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncode/html/secure01142004.asp
SafeInt and suggest might be combined with existing Boost code from date_time call constrained_value. this would allow you to define constrained range safe integers like this:
typedef SafeInt<int, 0, 255> BufRange;
char buf[BufRange::max()+1];
BufRange i = 254;
i++; //ok
i++; //out of range exception
//now it's impossible for this to be out of range:
if (buf[i] == ...
Suggested by Jeff Garland (jeff at crystalclearsoftware dot com)
Introduction: Fixed Decimal types provide an alternative to floating point types that are superior in their calculation properties. Robert Klarer of IBM has proposed adding these types to C++ [in n2198 (pdf)] and prior papers. This work is now on track to be included in C++0x. Robert has an implementation of these types with a restrained license. This project involves implementing the n2198 interfaces in a Boost library.
Goal: Platform independent code, docs and tests to Boost need to be delivered with as much of 2198 as possible.
Requirements: Basic knowledge of C++ templates and a good understanding of limits of computer computation systems. Extreme ability to focus on details.
Notes: This project clearly involves much less 'interface design' since the interface is already defined. However there is still tricky design work to implement these types correctly. Some research on the best approaches might be required.
Suggested by Jeff Garland (jeff at crystalclearsoftware dot com)
Introduction: [Java Script Object Notation (JSON)] is a widely used serialization format. Unfortunately, [Boost.serialization] does not have an [archive type] that supports JSON. So, the goal of this project is to create an input and output archive type for JSON. This involves figuring out how to parse JSON and recreate objects as well as writing JSON formats.
Goal: A json_oarchive and json_iarchive classes that provide serialization of json input and output. Requirements: Basic knowledge of C++. Knowledge of Boost.Spirit, Boost.Serialization, and JSON helpful.
Notes: [Boost.Spirit] is likely to be a handy way to create the json parser. There are already 2 non-boost projects that have done this:
Suggested by Jeff Garland (jeff at crystalclearsoftware dot com)
Introduction: [Boost.Math] has been significantly enhanced for Boost-1.35 to include a wide selection of special functions and statistical distributions. Currently the implementation does not make use of the multi-core capabilities of modern processors, but there might well be an opportunity to do so via OpenMP.
Goal: Evaluate how complex a routine has to be before parallelization via OpenMP becomes a viable option. Many of the key special functions in the library (for example the incomplete beta and gamma) are evaluated as the product of an asymptotic term and a dominant power function: would splitting this evaluation into two separate threads via OpenMP be viable? The student would have to devise tests for the performance benefits (or otherwise) of OpenMP based parrallelization and determine where OpenMP support is useful and where it is not. There may also be opportunities to optimise some API's via SSE2 vectorisation operations, and/or provide vectorised interfaces to some API's (i.e. evaluate the same API for many different values).
Notes: This could be an interesting project with lots of avenues to explore, but it could also turn into a very short project if OpenMP support turns out not to be not very useful after all! Consequently the student will need to be willing to change to an alternate Boost.Math related project (for example working through our TODO list, or adding additional statistical distributions or special functions) in the event that OpenMP has too great an overhead to be useful here. The student will also need access to an OpenMP enabled compiler (Visual C++ Express edition supports this I believe, as do very recent GCC releases), and one or more multi-core machines to test on.
Suggested by John Maddock (john at johnmaddock dot co dot uk)
Introduction: As the standard library and boost, the farm team for the standard library, have grown many older programs (and programs by older programmers :-) have been left behind. There is a need to pick up many of these old programs and update them to use the modern libraries.
Goal: There are four goals to this project. One, it will serve as a training ground for students in program maintenance, something that is widely cited as lacking in academic programs. Second, it will update numerous useful programs, making them smaller, more portable, better-performing and better documented. Third, these updated open-source programs will cease to be negative examples, leading more programmers to better use the libraries that are available. Fourthly, where "common algorithm" code is identified in programs that is not yet in the library, it will be extracted and abstracted from the programs in which it is found and converted into boost candidate library entries.
Requirements: Any student with an understanding of compiled imperative language technology, the ability to communicate in writing, and some experience with the concrete syntax and standard library of C++ can contribute. To independently select, refactor, test and republish a significant program would require in-depth experience with C++, some experience with interface design and the open source community, and access to diverse test platforms. It would be a good project for highly qualified students who have no specific project in mind.
Vision: To be highly effective, I believe the "CAMP" should involve multiple students and multiple mentors with frequent communications. A studio setting would be ideal but is obviously not practical under the SoC? structure. But the identification of good refactoring opportunities and the design of interfaces for the extracted libraries will both benefit from good informal communications.
Example: To make the concept concrete: take "make". The core algorithms and concepts are potentially useful in a wide variety of programs (consider prerequisites in an installer) and the code is old. If the core were suitable extracted we could even use the resulting library code in the kernel to sequence the initialization of drivers and other modules.
Suggested by Steve Nuchia (snuchia at statsoft dot com)
Some interesting projects were being implemented in Google SoC? 2006/2007. However most of these projects are not being worked on anymore. It seems there is a high abandoment rate for SoC? projects.
So I suggest that this SoC? 2008 we request that some of the existing projects be worked on.
For example in SVN there are interestingly Boost.Process Boost.CGI
It would be good to offer these to enhance further so for inclusion into Boost.
I'm not so sure this is a good idea. Some of them still have active authors. Some of them are 'so close' to being ready that there wouldn't really be enough project unless the goal was to actually hold a review during SOC -- something we've never tried. In any case, I've brought forward a couple of projects from past years that might be workable - Jeff G
Introduction: [Boost.Build] is the cross platform build description and management software used by the [Boost] C++ Libraries. In a robust development tools are as important as the programs developed with their help. In the case of Boost.Build it reduces the development burden placed on the numerous library developement community that participates in Boost. Instead of developing, testing, and fixing many different build system descriptions they can write a single cohesive build description which is used in all platforms. This allows for a distributed development and testing model, of developing on one platform and having others tests on different platforms, essential for Open Source software.
Goal: To construct a configuration file generation tool for [Boost.Build] ala GNUs [Autoconf]. The new tool should have enough functionality to replace the current [Boost.Config] [Autoconf] based configure script.
Requirements: Familiarity with, or drive to learn about: developing programs for multiple operating system, the Jam language, shell languages (CMD, Bash, KSH, etc.), and possibly ANSI C and Python. Even though knowledge of C++ programming is not required, it is preferred as that is the focus of the Boost C++ Libraries.
Introduction: Asio helps writing asynchronous network applications or socket related code in general. The overall concepts of ASIO, a more or less central io-service object and asynchronous handlers for certain completion conditions, can be applied in many other use cases. Support for handling user input events in various platforms is just one of them.
Goal: Provide an asio service that works well with the existing socket based services. It should be possible for a user of the library to provide handlers for the following external events:
Requirements: The student should have basic experience with win32 and direct input, since this is probably the most complex port of this library extension. Test environments for all supported platforms should be available. Furthermore the student should have average knowledge of C++, e.g she should be able to work with the current source code of ASIO.
Introduction: Introduce the main concepts around the project: Theoretical preliminaries, preexisting Boost libraries used (if any), important concepts, problems/needs the project will try to solve/satisfy.
Goal: Concise statement of the overall goal of the project. Refine this initial statement to include: project deliverables (code, docs, testing), required/suggested methodology, standards of quality, possible goal extensions beyond the main objective.
Requirements: List the requirements and level of expertise you estimate the student will have to meet: Required level of C++, specific areas of the language (STL, templates, locales, whatever), level of familiarity with Boost and particular Boost libraries, development/documentation/testing tools, mathematical/algorithmic background, other desirable skills.
Other sections: If you have more to say about the project that doesn't fit in the proposed sections of this template, feel free to add other sections at will. Oh, and don't forget to separate each entry with a horizontal line, entered at the edit box as ----