General Development Archive

libferris Winds its Way Towards 1.0.0

libferris is a virtual filesystem (VFS) that runs in the user address space. This means that applications using libferris will use the shared libraries API to access the filesystem which may then delegate to the kernel using libc to perform the desired actions. Operating in the user address space allows libferris to mount things that one would generally not want the kernel to mount. For example libferris mount Berkeley database files, ftp sites, XML files, rpm files, sockets, sysv IPC, mysql databases and remote computers using ssh as a filesystem.

Proposal for the Development of a Web Services Application

If there was a single application making someone use MacOSX full time, that application would be Watson. This application is possibly the most awarded in the MacOSX world, and it is the best idea for an application that I saw the last few years. Despite the idea being dead simple, and even seem redundant at first, Watson is an excellent, original and handy tool. I would like to initiate an open source project for a multi-platform clone of Watson (Karelia say that they have no plans for any ports - with only a remote possibility for a Windows port). I will start by putting $100 USD on the table while readers are most welcome to co-sponsor the project as well. What we really need though, is willing and capable C++ developers.

Overriding the GNU C Library

What do you do if you don't have the source for your application and it's failing because a GNU Library for C (glibc) function is returning something bad to the application? Override the function of interest with your own version. This can be done without having root permissions and without recompiling the libc source. Imagine the thrill of writing your own version of open()! The article contains sample code.

Writing Your Own Toy OS, PART II

"The next thing that any one should know after learning to make a boot sector and before switching to protected mode is, how to use the BIOS interrupts. BIOS interrupts are the low level routines provided by the BIOS to make the work of the Operating System creator easy. This part of the article would deal with BIOS interrupts." This is the second part of the series of articles on how to write your own toy OS.

The Technology Behind LynxOS v4.0’s Linux ABI Compatibility

"LynxOS v4.0, the newest release of the POSIX-conformant hard real-time operating system (RTOS), has support for Linux ABI compatibility -- where Linux application binaries can run unchanged in the LynxOS environment without necessitating source code recompilation. This white paper examines the issues surrounding ABI compatibility in general and describes the architecture of the Linux ABI compatibility layer on LynxOS v4.0." Read the article at LinuxDevices.

Rediscovering Object Orientation

"Does anyone really know what "object oriented" means? Does the phrase signify anything, or are the words just strung together because of an historical misnomer? One thing is clear. No one understands what the phrase "object oriented" means when they first hear it. While it does appear to be a juxtaposition of two ordinary words, its meaning does not jump out at you." Read it at CobolReport.

Journaling Filesystems for Linux

"This sample chapter from 'Linux Filesystems' begins by providing a detailed overview of how Linux identifies filesystems, verifies that they are usable, and makes them available to users. The remainder of the chapter explains the differences between journaling and non-journaling local filesystems, shows how journaling filesystems track filesystem changes, and highlights the major reasons why these types of filesystems are becoming more common on today's computer systems." The Part I, available at InformIT (free reg. req'd). "How is data storage organized and allocated on Linux and Unix systems? This article discusses the basics of Linux and Unix filesystem organization, highlighting some of the more modern approaches used to improve performance, deal with larger files, and solve other problems." Part II. "Minimizing system restart time is the primary advantage of using a journaling filesystem, but there are many others. As "newer" filesystems, journaling filesystems can take advantage of newer techniques for enhancing filesystem performance." PartIII.

Benchmarking Intel C++ 6.0 to GNU g++ 3.0.4

CoyoteGulch.com has published an interesting article, benchmarking GCC 3.04 and ICC 6 (the article will be updated again after GCC 3.1's release). In the tests, ICC seems to pull ahead in most tests. When it's behind, it's never very far behind. The opposite is not true, and there are benchmarks where ICC is very far ahead, generating code that can be up to 5 times better than gcc's. Especially interesting, the "Stepanov" benchmark, which shows that ICC is capable of understanding the most complex c++ constructs, whereas GCC gets confused by them and ends up generating much slower code. This is bothersome, because it means that developers who want to get the most speed out of their gcc-compiled system need to write their code pretty much in C, whereas those using ICC can use all the productivity-enhancing features of C++ without speed penalty. As for the "WhetStone" benchmark, shows that gcc still has serious issues dealing with x87 floating-point code. It would also be very interesting to run the very same benchmark on a Pentium4, varying the compiler options, in order to see how both compilers can take advantage of the Pentium4's extra features, and especially SSE-2. Update: Another benchmark can be found here.

Alternatives to the Registry

Microsoft stores system configuration information in binary format in its Windows Registry, but other vendors take different approaches to achieve the same goal. MacOSX uses text files in XML format, while Solaris features a more complex system instead. Linux still uses flat text files for configuration, however Red Hat encourages the development of GConf, a registry-like system and library, that programs can use to store key-value pairs persistently. Read the interesting article at ComputerWorld.

C# Striking a Chord with Programmers

"Microsoft's new C# programming language is gaining in popularity, with usage nearly doubling in the last six months, a new study shows. C# is Microsoft's new Java-like language and a crucial piece in the software company's .Net Web services strategy, in which software is made available over the Net to be accessed by multiple devices, such as PCs, cell phones and handhelds. Twelve percent of all North American software developers have begun using C#, up from 7 percent six months ago, according to a new survey by market research firm Evans Data. The firm also predicts that the number of programmers using C# will double to 24 percent in the next year." Read the rest of the report at News.com.

Writing Your Own Toy OS, Part I

This article at LinuxGazette is a hands-on tutorial for building a small boot sector. The first section provides the theory behind what happens at the time the computer is switched on. It also explains our plan. The second section tells all the things you should have on hand before proceeding further, and the third section deals with the programs. The little startup program won't actually boot Linux, but it will display something on the screen.

Intel Releases V6.0 Compiler Suite

News from Slashdot: ""Intels C++ and Fortran compilers are now available for Windows and Linux. The compiler for Linux provides higher compatibility with the GNU C-compiler including compability to the upcoming GCC-3.1 C++-ABI (binary compability) and support for several GNUisms in the syntax (PDF). To quote Intel: 'The 6.0 release of the Intel C++ compiler has improved support for the GNU C language extensions and is now able to build the Linux kernel with minor work arounds for both the IA-32 and Itanium architectures.' Little reminder: Running such a kernel is, of course, not supported by the kernel developers. Evaluation copies are available for download, but requires previous registration."

Emulate This! with Bochs – Part 3

"Bochs is an emulator for the x86 hardware platform. In other words, it can emulate a PC of varying hardware configurations. When you boot into Bochs, it will appear as though you are booting another PC from inside your own PC, and in a way, you are. Bochs emulates the entire PC platform, I/O devices, memory and its own BIOS. What's even more interesting is that you don't have to be running PC hardware to run Bochs. It will emulate x86 hardware on any platform on which you compile it. By changing the configuration, it is possible to specify the type of processor (386? 486? 586?), the amount of memory and so on. Bochs is a box inside your box. In fact, Bochs is as many boxes as you want it to be. It even has its own power button." Read the third part of the emulation articles at LinuxJournal.

GCC 3.1 Pre-Release Almost Ready

Mark Mitchell, the GCC release manager posted at GCC's mailing list that a GCC 3.1 pre-release test version will be ready any time now, today or tomorrow. GCC 3.1 is the first "stable" version that developers were awaiting to base their projects on, as in some cases it delivers up to 30% faster executables than GCC 2.9x.x for the same codebase. GCC 3.x is a bit slower in compilation times than GCC 2.9x.x, but it creates faster executables, so it worth the extra time it takes in order to utilize the extra optimizations (a tip: compiling GCC 3.1 itself with the Intel compiler (which creates about 35% faster code than gcc 3.x), it would optimize GCC and it will make it require less compilation time). GCC 3.1 also has an extra flag for specific Pentium4 optimizations while it is more C++ compliant (lays out stricter rules for the C++ devs). Macintosh users should also await this release, as the new GCC seems to offer about 5% faster code than the previous GCC for the G3/G4 architecture. Apple has already switched internally to GCC 3.1.