General Development Archive

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.

C# Example of MSN Messenger on Windows and FreeBSD

From DaemonNews: "François Jacques and Jean-Claude Batista have an article on macadamian.com on writing a tiny version of the MSN messenger client on Windows and FreeBSD . The example is available in source code form for free." Our Take: It feels a bit strange to have software compile for the .NET Framework under FreeBSD. It is definately a welcoming addition to FreeBSD, but it still feels a bit strange. We'll get used to it, I guess.

Using Threads With C#

This article over at MSDN explains the different models of threading — single, apartment, and free — and the use of each model. It also introduces a code sample in C# that uses threading to help you write applications that will take advantage of threading. The article also discusses important issues involved in multithreading code.

Advanced Filesystem Implementor’s Guide, Part 10

With the 2.4 release of Linux come many new filesystem possibilities, including Reiserfs, XFS, GFS, and others. These filesystems sound cool, but what exactly can they do, what are they good at, and exactly how do you go about safely using them in a production Linux environment? Daniel Robbins, CEO and president over at Gentoo Linux (and creator of the sophisticated Portage packaging system) answers these questions by showing you how to set up these new advanced filesystems under Linux 2.4. In this final installment (Part 10/10), Daniel shows you how to get XFS up and running on your system and explores some of XFS's more advanced features. Recommended reading is also the previous article, Part 9, exploring XFS's features over the other Linux filesystems. In a similar recent article, Bert Scalzo for Linux Jounral, benchmarks ReiserFS, JFS and ext2/3.