Keep OSNews alive by becoming a Patreon, by donating through Ko-Fi, or by buying merch!

General Development Archive

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.

New Versions for Bochs, VMWare and Virtual PC Released

Bochs 1.4 is the latest release of Bochs, the popular x86 emulator. This version delivers features such as booting from a CDROM, VESA BIOS Extensions, improved networking, keyboard mapping for non-US keyboards, and a working serial port. You'll notice several new buttons on the GUI, copy, paste, and snapshot, which let you copy text between the system clipboard and the Bochs screen. There is also a new cross-platform interface using the SDL library. In related news, VMWare has just released a beta of its upcoming VMWare 3.1 x86 runtime (VMWare is not an emulator like Bochs and VPC are, this is why it can't be ported to any other architecture than x86 - however, by being a runtime, it is speedier than the emulators), while Connectix released its x86 emulator, Virtual PC 4.3, just 15 days ago.

Vesta Releases First LGPL Version

Many are the developers who prefer Perforce in favor of CVS. There is a new player in the field now though. It is called Vesta and it is a replacement for both CVS and 'make'. It handles source revision control and automated construction. It is the result of over 10 years of research and development at the Compaq/Digital Research Center. Just last August Compaq gave the 'ok' to LGPL Vesta and since then the 4-member team worked hard to finish up the port to x86 Linux (prior to that, Vesta only worked on Alpha and Tru64 systems). Now, the first Free version is available for download. For a summary of some of the features that make Vesta interesting, see this page.

Compiler Security Checks In Depth

"Software security is a major concern for the high-tech industry, and the most feared and misunderstood software vulnerability is the buffer overrun. Today, the mention of a buffer overrun is enough to make people stop and listen. All too often, the technical details get lost in the transcription, and the general public comes away with a rather alarming view of a rather fundamental problem. To address this problem, Visual (unmanaged) C++ .NET introduces security checks to assist developers in identifying buffer overruns." Read the rest of the article at MSDN.