As a team of volunteers brought the operating system back to life.
It happened in the summer of 2001, when programmer Michael Phipps had a problem: his favorite operating system BeOS was on the verge of extinction. Feeling emotional attachment to some kind of software may seem amazingly strange, but for Phips, like many others (including me), BeOS deserved it. She worked amazingly fast on the hardware of the time; she had a clean, intuitive user interface; and it provided a rich, fun and modern programming environment. In short, we have seen that it is significantly superior to any other operating system available. But the
company that created BeOS could not break into the market, and its assets, including BeOS, were sold to a competitor.
Concerned that with the new owner BeOS would die a long agonizing death, Phips made the only logical step: he decided to recreate BeOS from scratch, but with open source code. An open system, as he reasoned, is not owned by any company or person, is not able to disappear just because the business is going bad, or the key developers left the company.
')
If you’ve ever programmed, you can imagine that building an operating system is a lot of work. And expecting people to do this when they are not paid would be a bit incredible. But for the dozens of volunteer developers who worked on Haiku, it was a labor in the name of love. Over the 11 years since the founding of the project, we have released 3 alpha versions of the product, and this month we expect to release the 4th, final alpha version. After that, we move on to the beta phase, which we hope to finish before the end of this year, followed by the first official release, known as R1, somewhere in early 2013.
Today, anyone can install and run an operating system on an Intel x86-compatible computer. Many users point out that even the alpha versions of Haiku seem to be as stable as the final versions of some other products. Specifically, among the variety of operating systems in development, Haiku is perhaps the most focused on competing with common operating systems such as
Microsoft Windows and
Mac OS . For users and developers, the experience with Haiku is amazingly cohesive: it is fast, responsive and efficient, like BeOS. In addition, Haiku, unlike its well-established rivals, is surprisingly good at solving one of the hardest problems of modern computing - working with multi-core microprocessors. Let's see how Haiku came to this, and whether the operating system of your computer works well.
For a start, a little history. In 1991, a Frenchman named
Jean-Louis Gassée together with several other former Apple employees founded Be Inc. because they wanted to create a new generation computer. In particular, they wanted to avoid the trap of backward compatibility that they witnessed at Apple, where each new version of hardware and software had to take into account the years of past systems. The first product of the company was a
desktop computer called BeBox . Not finding any suitable operating system, Be engineers wrote their own.

Released in October 1995, BeBox did not last long. BeOS, on the other hand, quickly gained a small but loyal group of supporters, and soon worked on Intel x86-compatible PCs and Macintosh PowerPC clones. At one point,
Apple even considered BeOS as a replacement for its operating system. As a result, the company released a stripped-down version of BeOS for Internet equipment, but this was not enough. In 2001, Palm acquired Be for
$ 11 million announced.
Even while the Be deal was coming to an end , Phipps launched the Haiku project, known at that time as OpenBeOS (the name was changed by community vote a few years later).
From the very beginning, Phipps decided that the only goal of the project would be to recreate the latest official version of BeOS, known as R5. Looking back, you realize that it was a brilliant move. Open source projects, as a rule, are made for their own pleasure in their free time, often exhausted and postponed, without achieving anything substantial. Haiku avoided such a fate, because all the developers believed in the possibility of re-creating R5.
Yet, Phips and those who joined him had a very difficult task. The operating system is extremely complex, especially as large as BeOS, whose many layers and applications were designed initially for collaboration. Some of the most talented engineers in Silicon Valley have been developing the program for over 10 years. The re-creation of such a system by a team of volunteers in their free time was a crazy idea. But this is exactly how Linux appeared, just like the
GNU software from the Free Software Foundation, starting with the GNU C compiler and ending with GnuCash, an accounting program.
Fortunately, BeOS was written in a modular style, allowing you to simply develop, test, and then replace each of the BeOS components with its open source counterpart. Some parts of BeOS have already been released by Be in the open source, such as
Tracker and
Deskbar , which are analogous to Explorer and Taskbar on Windows, as well as Finder and Dock on OS X. One of the first pieces of code written by volunteers was the screen saver toolkit ( screen-saver kit), which has a very simple function, but also many details. Among other things, he should constantly monitor keyboard and mouse activity, load screen storage settings at the right moments, and ask for a password when
the screen saver is turned off. When everything was sorted out, Phipps replaced the BeOS screen saver with its open source version, and to everyone's surprise and joy, it worked. More importantly, it was proof of a concept showing that developers can replace each of the BeOS modules, knowing that they will be fully compatible.
In 2008 we reached milestones. The achievement was that for the first time we were able to build the Haiku source code from under Haiku itself; programmers call this
self-hosting ability. This stage is critical for the development of any operating system, because without it, the OS will always depend on other systems.
While the development was in full swing, Phipps worked on the creation of an organizational unit for Haiku, eventually establishing Haiku Inc. as a non-profit organization in 2003. In addition to monitoring the project and accepting donations, Haiku Inc. owns the rights and trademarks of the Haiku website, its logo and, of course, the source code. All Haiku code is now available under an
MIT license , allowing full and free access to code for everyone, including private companies and other open source projects.
Of course, the Haiku team must be careful not to violate BeOS patents, which are still valid. As a rule, we maintain friendly relations with the
Japanese software company Access , which now owns the rights to BeOS; for example, the company allows us to post the BeOS documentation on our website, and it never interfered with our attempts to reproduce the BeOS technology. Would Access, or any other company that thinks it has the rights to our code, sue a small project like us? Financially it would not make any sense, and also create a bad reputation for the company. But we can only wait and see for ourselves. Judging by the current mad state in intellectual property litigation in the United States and anywhere else, not a single software product can be called completely immune to the problems of legality.
In 2007, Phipps announced he was leaving the project for personal reasons, and a new group of people seized Haiku Inc. As he expected before leaving, the loss of the leader did not doom the project to death. I am currently a treasure keeper and, along with other executive directors of Haiku Inc., am a member of the board of directors. So far, we have maintained momentum, and at the last
meeting in April
in DĂĽsseldorf, Germany , the Haiku developers worked on the upcoming alpha version.
At the moment we have reproduced BeOS R5 so accurately that even old BeOS applications, which are now more than 10 years old, can work on Haiku. When the project was just launched, many thought that this kind of compatibility would be impossible. In many areas, Haiku even surpassed its predecessor. For example, Haiku supports more languages ​​than BeOS, and is more compliant to translate into other languages. It also supports modern video cards, new processors, access to wireless networks and allows you to use more memory than BeOS.
And in terms of programming, Haiku greatly facilitates the design of user interfaces for applications, because it has a
built-in layout tool that allows you to automatically place icons and other widgets on the screen. With BeOS, developers had to specify every detail of the layout, align buttons with checkboxes manually, for example. These and other improvements have allowed Haiku to remain effective, given the lightning-fast pace of innovation in computer hardware and software.
You might be surprised: with existing Windows, Mac OS X, hundreds of Linux versions and countless mobile OSs, does the world really need Haiku?
Yes, it is, for many reasons. In many ways similar to natural ones,
computer viruses are blooming in mono-culture , and because there are so many Windows computers among us, Windows viruses find many victims. Further, if one operating system has established a monopoly, its creators do not make much sense to improve the software. (The
challenge from Mozilla Firefox is, after all, the driving force for Microsoft to update Internet Explorer). Also, diversity leads to mutual compatibility, because it encourages software developers to create code that works seamlessly with others. When there is no competition, there is no driving force to strive for it.
But Haiku does more than just expand the gene pool of operating systems. One of the first things that people notice about Haiku is that it doesn’t look like Windows or OS X or Linux. She is unique. Linux, for example, is based on the kernel (
kernel ), which was originally designed for use on servers and only then was
adapted for desktop systems . As a consequence, the kernel sometimes runs through the user interface, which Linux users feel like irritable delays when their computers do something heavy, like burning a DVD or building code. The Haiku kernel has always existed for personal computers, and, as expected, it always gives priority to what happens with the graphical user interface.
Between the kernel and the graphical interface, there is what is called
an application programming interface , or API. The API is what application developers use to access other software systems; API design influences both developers and immediate users. Haiku has only one API. Linux, by contrast, has hundreds of APIs and about as many user interfaces, so you cannot switch seamlessly from one version of Linux to another. The version you use can significantly change the appearance of your computer screen, methods for loading and executing programs, and many other things, all of which complicate the development of an application that performs equally well on all Linux systems.
All Haiku components are originally built for collaboration, including applications such as a media player and a web viewer. Their source code is made in a strict style that the developers are very fond of, because it allows them to quickly pick up speed. The developer who writes the code for Haiku can be sure that he will work and behave the same on all machines with Haiku. Despite the fact that Haiku is open source, there will always be
only one official version . All this is done to ensure harmonious work in the system.
What really sets Haiku apart is its efficiency and speed. On my 3-year-old desktop computer, Haiku boots from a cold start in 10-15 seconds and takes only about 170 megabytes of RAM during operation. Compared to other operating systems, it is the most efficient use of computing resources. Haiku feels fast and responsive even when running on older systems that would otherwise be considered obsolete, because they can no longer cope with the inefficiency and workload of other operating systems.
In many ways, the effectiveness and speed of Haiku is a direct result of the BeOS heritage. BeOS was originally designed to maximize the use of streams, which in computer terms are sequences of executable code. Just as a fabric consists of many threads woven together, so the operating system is made up of threads that divide processor time. Usually allocated to the flow for each application, plus one to the user interface of the operating system. The problem is that the user interface, in particular, requires more than one thread. Those “Application not responding” messages in Windows and the “
beach ball of death ” in OS X, which all of us have seen more or less with disappointment, are a direct result of using only one thread for the user interface. When this thread is too busy to work, or there is another problem (such as a slow network), the interface of the entire application is stuck.
This did not happen at BeOS, and it didn’t happen at Haiku. Where BeOS was ahead of other operating systems of the time (and where Haiku is still ahead of modern operating systems) is that each application uses many threads. The application kernel itself is a stream, plus each application window creates a stream. This complicates the code a little, but as a result, applications almost never slow down and do not jam.
For a system to be multi-threaded, it means that Haiku can make good use of multiple processors or CPU cores that are ubiquitous. The Haiku kernel allows each thread to work on its own core or processor, including threads within a single application. Adding threads to other tasks, such as retrieving data from the network, is also simple. Other operating systems resort to using many cores only when running many applications at the same time, or when an application has a special multi-thread code implemented for it. But this multithreaded code is complex, so most applications cannot boast of it.
Haiku
simplifies the process of writing multi-threaded code by hiding most of the interaction between threads, so developers do not need to think about it. This is largely due to the extensive use of the message mechanism. Let's say Stream A and Stream B in the same application both want to get a piece of data from Stream B. Instead of directly accessing this data, Stream A and B are sent by message, which are placed in the central message queue and processed in a certain order. Without this mechanism, two threads would try to access Flow B at the same time and get deadlocked, as a result of which they would wait for each other forever. In Haiku, messages can be sent both within the application and other applications. Thus, the Haiku messaging engine assumes all the complexity of managing threads, freeing it from this developer.
The main reason BeOS used multiple streams was because BeBox was conceived as a media platform. In fact, one of the BeOS ad names was
Media OS . Although the advertisements slightly outweighed the dignity, the system was really good at multimedia. In a typical demonstration, BeBox played half a dozen different video clips at the same time without delays and dropped frames, while the system remained responsive. The efficiency of the system also made it possible to process the audio signal with low latency. While Haiku still has a lot of work to do in these areas, it is already far ahead of many other systems.
Another advantage Haiku has over others is the extensive use of a
file system like a database , which allows any file to have
various properties associated with it. These properties can be indexed and retrieved in the same way as in a regular database. For example, each e-mail (e-mail) in Haiku is stored along with properties such as: subject, sender name with address, recipient name with address. From the file management program, known as Tracker, you can search for any of these properties. The properties also allow you to extract song information from MP3 files, as well as easily organize and find files in your music library via Tracker. Entries in the Haiku address book, known as
People files , consist almost entirely of such properties.
Allowing your OS to organize your address book is an advantage: you are no longer tied to just one program that manages your emails and contacts. , - Microsoft Outlook, . , , , Haiku — . People files Haiku , Tracker. .
, Haiku , . , - . : , , — , -. . Haiku , , BeOS.
, Haiku
. -, , : , — . . , .
, Haiku , Linux, FreeBSD . Haiku FreeBSD -.
Gallium3D , - Linux.
, Haiku, , , . Linux , Haiku, , , . OS X Snow Leopard Apple
Grand Central Dispatch , . , « » .
Windows 7 , , , . . Windows :
Windows 7 Ultimate 20 . , Haiku, 700 — Windows 7. — Windows Mac OS .
, Haiku - . , , , «» , , , , , , Haiku - .

.(
Ryan Leavengood ) — Boynton Beach, Fla.,
Ruby on Rails . Haiku 2003 , . , , « . , , , , , ». , (Francesca) , .
: BeOS Haiku, . , .
GSOC — . , , .
:
The Dawn of Haiku OS .
, , .