Ideas List for Google Summer of Code 2008
ES operating system has been accepted in to the Google Summer of Codeā¢ 2008 as a mentoring organization. Here is the list of ideas for the ES project. We welcome your application for GSoC 2008 with any of the ideas listed here or with your ideas related to the ES operating system.
A pure component operating system kernel design and development
- Improve the quality of code.
- Support x64 as now Newlib has an x64 support.
Recommended readings
- Douglas E. Comer, Operating System Design: The XINU Approach, Volume 1, PC Edition.
- Maurice J. Bach, Design of the UNIX Operating System.
- Stanley B. Lippman, Inside the C++ Object Model.
Comer's book gives you the good understanding how to implement the abstract concepts in the operating systems as real pieces of program code. Bach's book describes the design of the traditional Unix kernel in pseudo code with reasonable details. You will learn many useful examples on concurrent programming from this book. As the ES kernel is written in C++, you must be familiar with the C++ programming in general. Even though Lipman's book is based on a bit older C++ implementations, it describes the runtime data structures and mechanisms behind C++, which you need to know for writing an operating system kernel in C++.
In this area, we still need to do a lot more work to improve the quality of the kernel to the production level. And now that Newlib has an x64 support, supporting x64 in addition to x86 will be an interesting kernel project, too. Many ES software components are already 64-bit ready since we've tested them on x64 linux. Therefore, adding a new virtual memory management subsystem will be most major work for x64 support.
A component object binding runtime implementation for ECMAScript
- Support function/attribute overloading, structures that are used in IDL definitions.
- Enhance the esidl IDL compiler to support overloading, etc.
Recommended readings
We often read the formal standard specification documents when designing and implementing operating systems. Sometimes standard documents are written in a very difficult way to read through, but ECMAScript Language Specification is written in an easy way for interpreter implementors. Since both esjs and esidl are relatively small programs, reading these specifications comparing the current implementations would be a good starting point to understand the issues where we need to enhance the current implementations.
Note that the implementation of our ECMAScript interpreter esjs is not for the optimal performance. We are rather concentrating in the object binding runtime implementation between ESCMAScript and the other native software components. So if you have more strong interests in the fast ECMAScript VM implementation, the ES project might not be for you since there are other important open source activities designing and developing the super fast ECMAScript VM implementations.
An HTML5 rendering engine integration
- Looking for an engine that uses Cairo and FreeType.
- Just incorprating the portions really necessary to run the Lively Kernel can be a good starting point.
Recommended readings
The interfaces defined in the HTML 5 specification will be the standard interfaces for the ES operating system, and we will work on an HTML5 rendering engine integration. We have just implemented CanvasRenderingContext2D interface using Cairo and FreeType, and there are a lot more works need to be done. As a whole picture, running the Lively Kernel on top of the ES operating system is a very close image of the future operating system we are thinking about. Therefore, incorporating only the portions of the HTML engines that are really necessary to run the Lively Kernel can be a good starting point for you.
A TCP/IP stack implementation based on design pattern
- Finalize the interface definitions for socket, etc.
- Support IPv6.
Recommended readings
- W. Richard Stevens, TCP/IP Illustrated, Volume 1: The Protocols
- W. Richard Stevens, and Gary R. Wright, TCP/IP Illustrated, Volume 2: The Implementation
- Hermann Hueni, Ralph Johnson, and Robert Engel, A Framework for Network Protocol Software
Because of the great series of books by Stevens, we can explore the design and implementation of the TCP/IP protocol stack more easily than before, but it is still very very difficult to fully understand TCP/IP. We believe reimplementing a TCP/IP stack using the design patterns helps fully understanding TCP/IP, and we are currently using the Conduit+ model for this work. There are really many uncompleted tasks in this area. You will work on designing the socket interfaces in IDL, making the current implementation more robust, etc. If you are seriously studying the network architecture, this project would be an interesting one for you.