Developer Area Developer Area

Becoming A Be Developer

Becoming A Be Developer

Join Registered Developer Program

Registered Developer Area

Developer Library

Developer Library

Developer Events

Search Contact

Why Develop for the BeOS?

Digital media. Interactive design. Media convergence. The World-Wide Web. Digital editing. You see the terms everywhere in the computer industry. Personal computers are at the focal point of a merging of video data streams, audio information, 3-D models and visualization, communications capabilities, and graphical data. From these ingredients will emerge new products that will integrate the features we see today in PCs, televisions, radios, telephones, and a host of other electronic devices.

Software developers understand what it will take to make this digital convergence a reality. They know it will take higher bandwidth communications and new software tools. They know that dealing with digital media will take much more processing power than they can get in today's personal computers. The industry is attempting to address these issues, with new companies being formed every week on the promise. New software is bolted onto current operating systems; new tools that handle complex data are introduced. And users are being bombarded with new software which presents an unbelievable array of capabilities -- and complexity.

Complexity -- there's the hitch.

The very solutions that should enable media convergence are unapproachably complex. Complexity increases costs while customers expect falling prices. Complexity decreases a developer's productivity and lengthens the time it takes to bring a product to market. Complexity increases software overhead and consumes processing power. And most of all, complexity drives end users crazy -- in purchase decisions and in product use -- making personal computers less approachable and, ironically, less useful.


Out-of-Date Assumptions

This growing complexity is a symptom of a larger problem. The decisions that the computer industry's main players make are based on several key assumptions that are well over two decades old:

The Uniprocessor Assumption

Today's PC architectures were designed over two decades ago, in an era when microprocessors were expensive. Today, microprocessors are commodities. Yet, we're still using operating systems that can only run on one processor, even though multiprocessor configurations would deliver a new level of price-performance. As a result, products deliver less performance than is inherent in the hardware, at prices that are higher than they should be. And even if the customer of an application uses a uniprocessor machine, the developer of that application, working many months earlier, would benefit from developing on a multiprocessor machine that provides an equivalent level of performance to next year's customer's uniprocessor machine.

OS Assumptions: Aging DNA

Many of the capabilities required by digital media simply weren't conceived of when today's PC architectures were created. Place yourself in the role of a systems designer twenty years ago. Real-time, high-bandwidth media? Interactive manipulation of megabytes of data? The Internet? Theories, maybe. Reality, not. The result is a cost and performance drain created by the need to bolt, shove, and cram these new pieces of functionality into architectures that simply can't handle them. Programming models are so riddled with rules and exceptions that new applications take years to come to market and consume more and more memory and processing power. The industry is attempting to deliver the next decade's solutions using architectures designed to solve the last decades' problems.

The Compatibility Assumption

Each year, advances in hardware significantly improve the speed -- and cut the costs -- of computer processors and peripherals. But the end user sees only a small fraction of the increased power delivered by new hardware. Software developers know what's happening: The power that's delivered by new, faster hardware is being lost in a morass of software overhead created by the "need" for backward binary compatibility.

Backward compatibility isn't a bad thing -- but are we getting our money's worth striving for binary compatibility when network and data compatibility are far more important? The standards that increasingly matter today -- HTML, VRML, JPEG, MPEG, MIDI -- don't involve binary codes. These are the standards that determine interoperability in a net-connected world.


Increasing Demands for Power

The expectations of today's personal computer users are increasing rapidly. They demand the functionality and performance that they see on workstations, but their price expectations are driven by the high-volume PC market. Moving against these expectations is a rising tide of complexity, decreasing performance improvements, and increasing product delays.

The experience of the people at the heart of multimedia activity -- the digital designers who create CD-ROMs, DVDs, Web sites, and print ads -- is similar. They buy high-end personal computers, stuff them with expensive high-performance graphics cards, communications devices, and high-speed I/O options -- but they still can't get the performance they need. Digital designers are consuming processing power faster than it's being delivered to the market.

Their numbers are growing, increasing at a rate that's some three to four times the growth in the PC market overall. Their frustration is growing as current PC architectures fail to keep up with their needs. These users represent a shift in the personal computer market -- a set of consumers who are actively searching for new solutions. They don't need to be convinced that they need digital media capabilities; they already know it.

These new multimedia consumers present software developers with a major opportunity to build new business franchises and to be in at the ground floor of a transformation in the industry. But taking advantage of this shift means delivering products that meet these customers' needs. And doing so with today's personal computer architectures is increasingly complex and difficult.

In addition to these current, frustrated, multimedia users is a largely untapped market: home users, amateur and semi-professional musicians, videographers and other creative people who are unable to achieve the results they'd like on low-end platforms. Given the right low-cost tools, they could, and would, produce a large amount of high quality audio and video content. And, just as the majority of customers for Nikon professional cameras are enthusiastic amateurs, amateur or semi-professional musicians, videographers and artists would like to have access to professional tools at affordable prices.


Challenging the Assumptions

We're faced with a set of users who are demanding the interactive design capabilities and power available in workstations, but at prices similar to today's PCs. Given the architecture of today's personal computer, how can we reach this new level of price-performance quickly? And how can we solve the problems of increasing software overhead, time-to-market, and complexity?

Be, Inc. was formed to address these issues head-on -- to see what could be accomplished if you designed a new personal computer operating system using new assumptions based on cutting-edge software concepts. The result is a new level of price-performance, and a dramatic reduction in the complexity of software development. The assumptions on which Be's products are based include the following:

One Processor per Person is Not Enough. There are computer systems on the market today that use more than one microprocessor. But almost all of them are used as servers, or in expensive, turn-key installations. Be's focus is to bring the power of multiple processors to personal computing, and to apply that power so individuals can do things that are too difficult and time-consuming today. This certainly describes the demands of many applications in digital video, digital audio, image processing, 3-D, and communications. It's our belief that the multiprocessor approach is the most cost effective way to deliver this power at a low price point. This multiprocessor approach provides scalability and flexibility. The BeOS runs just fine on a single processor machine. Add more processors, and the performance scales to exploit the additional processing power available.

Build in the Future. Be's products are designed with the applications of the next ten years in mind. We build products that are focused on media and communications-based capabilities, while providing a fast, light-weight software foundation.

Learn from the Past, Don't Blindly Copy It. The industry has learned a great deal about building and improving software and hardware over the last twenty years -- experience that Be has taken advantage of. But while learning from the past, Be's products don't copy it. For example, data and Internet compatibility is of paramount importance within Be's products, enabling them to take advantage of a wealth of existing information. But we've intentionally avoided older software programming architectures that are ill-equipped for newer application areas, or that would interfere with the goal of increasing performance.

Ride with Industry Cost Curves. Each year personal computer users can purchase twice the hard drive capacity for the same dollar. New peripherals come to market; CD-ROM drives increase in performance and decrease in price. The personal computer industry is so large that it generates its own unique dynamic of increased capacity and lower prices. PC users want to be able to ride these curves -- and that's exactly what Be delivers. Be's products make use of industry-standard components that are readily available, constantly improving, and easily replaceable. This strategy means that Be's focus is not simply on performance, but on price-performance.

To achieve these goals, Be has abandoned old architectures and concepts. We're not backward compatible -- we don't support twenty-year-old ideas. But for users who are involved in digital design and who need more power than today's platforms can deliver -- and for developers who are building the tools these types of people use -- Be represents a new field in which to lay down fresh tracks.


Breaking Barriers: The Be Operating System

The heart of the Be product line is the Be Operating System (BeOS(tm)), a new software system designed for the media and communications-based applications of the next decade. While retaining compatibility with data and network standards in use today, the BeOS jettisons many of the assumptions inherent in older OS architectures to achieve a new level of performance, and a significantly simplified programming model. The BeOS features:

A Fully Threaded System. The BeOS is a pervasively threaded system, using a thread model that is light in memory usage and thread creation time. The application model is designed to divide an application into multiple threads even if the programmer doesn't explicitly do so. For example, every window in the OS is controlled by its own thread, which is initiated automatically simply by creating a window object. Furthermore, the OS is reentrant: Any object can be used by any thread. Threading increases the efficiency and performance of applications. Reentrancy allows developers to structure their applications for simplicity and performance without worrying about architectural limits.

Symmetric Multiprocessing. Even a single-processor machine can take advantage of a threaded operating system. But the primary reason for designing software this way is to take advantage of multiple processors in a single personal computer. The most intelligent way to do this is to allow threads to move from one processor to another depending on system load -- a process called symmetric multiprocessing. This is exactly what the BeOS accomplishes, supporting one, two, four, or more processors. The result is significantly greater parallelism on multiprocessor systems, and significantly higher overall performance throughout the system.

Object-Oriented Design. The application programming interface (API) of the BeOS is object-oriented (written in C++). Creating a window within the BeOS, for example, involves simply creating a BWindow object rather than having to procedurally construct the data structures and call a myriad other routines. Furthermore, the Be API is a full application framework. When new features are added to the BeOS, they're added to the framework, enabling them to be used immediately by programmers to enhance their applications. There is no delay waiting for a separate framework to "catch-up" to the new features of the OS. The result is faster time-to-market for new applications, and faster revisions to existing applications.

Designed for Real-Time Media and Communications. The structure of the BeOS is optimized for dealing with real-time, high-bandwidth data signals, such as audio and video, and for handling a wide array of communications capabilities. These capabilities can be found within the BeOS Media Kit, and within several of the built-in servers, such as the Audio Server.

Simplicity. Throughout the BeOS, there has been a heavy emphasis on delivering simple, elegant solutions to programming problems. The API is simple because we started from scratch. We designed a new OS using everything learned over the past twenty years of software design, incorporating the good, ignoring the bad, and streamlining the result. For example, a single object, BMessage, is used for inter-application communication, cut-and-paste, drag-and-drop, client-server communication within the BeOS, and for distributed communication over networks. In current software architectures, you need a separate interface for each of these tasks. The attention to simplicity within the BeOS stems from an underlying belief that software programmers are most effective and efficient when the entire OS model can be understood by each programmer.

Considerably more can be said about the features of the BeOS, and the benefits obtained through its architecture. But overall, the end result of the structure -- the goal of the OS design -- is superior performance and reduced time-to-market.

Superior Performance. From uniprocessor systems up through four processor systems (and more), the BeOS makes optimal use of the underlying hardware, significantly reduces OS overhead, and increases parallelism compared with other mainstream OS architectures.

Reduced Time-to-Market. The Be API is extremely simple and compact. Developers working with the BeOS have already proven that they can be more efficient writing for the BeOS than for current mainstream architectures -- reducing development costs and speeding time-to-market.

Superior performance and reduced time-to-market go hand-in-hand -- in order to be fast, an OS must be compact; a compact OS is easier to learn and faster to program. These two goals will remain central to the design of the BeOS.


BeOS Structure

The BeOS can be divided into three layers. At the bottom, right above the hardware, is the microkernel. Above the microkernel is a wide array of servers, providing higher level services to application processes and to the OS itself. Finally, the object-oriented set of software kits is the programmer's interface to the operating system. In addition, the kits combine the functions of various servers into more complex capabilities.


The BeOS employs a microkernel to abstract the hardware and to provide basic OS services. As you might expect, the Be kernel is optimized to take advantage of multiple processors, and for handling large numbers of simultaneously executing threads. Programmers can access the kernel directly by making system calls (global C functions), or they can use the object "covers" (such as BLooper and BLocker) that encapsulate kernel functionality.

Kernel capabilities can be extended through software drivers, which are dynamically loaded and unloaded as needed by the system.


A wide array of software servers encapsulate key areas of functionality used by applications and by the OS itself. Examples of these servers are the Storage Server, which provides file system and database functionality, the Network Server, which provides TCP/IP capabilities, and the Audio Server, which handles real-time audio streams from a variety of sources. These servers are automatically started at system start-up, are designed around a client-server model, and are heavily threaded themselves.

Software Kits

The capabilities of the servers are accessed through the various software kits available in the BeOS. Each kit is made up of a set of C++ objects, which can be used and subclassed. (Exceptions to the C++ rule are the Network and Kernel Kits, which are C-based for simplicity and ease-of-use.) These objects in turn call the servers -- and each other -- to accomplish more complex tasks. Examples of the software kits are the Interface Kit, handling most window, view, and drawing functions, the Application Kit, handling application-level capabilities and communications, and the Media Kit, handling audio and video capabilities.

The array of BeOS software kits provide a wide range of classes and functions that applications use to build complex capabilities. These kits are constantly being extended and improved by Be through each release of the BeOS. A sampling of the core software kits includes:

Application Kit
Contains core application objects, such as BApplication, BMessage (for communications), and BLooper (for creating new threads).

Storage Kit
One of the key advantages of the BeOS is that it provides both file system capabilities and integrated database capabilities. The BeOS file system is a modern, 64-bit journalling implementation, providing support for the very large files inherent in handling digital media, and the robustness demanded by users of such data.The Storage Kit works with the Storage Server to provide objects such as BFile, BDirectory, and BDatabase.

Interface Kit
The largest of the kits, the Interface Kit works with the Application Server to provide objects such as BWindow and BView, which provide the basis for other interface objects such as BListView, BCheckBox, BTextView, and many others. The Interface Kit (through BView) also encapsulates all drawing capabilities.

Media Kit
The Media Kit handles real-time streams of data through the system - which means it's the kit that deals with audio and video streams. The kit employs a "subscriber" model, through objects such as BAudioSubscriber, which allows multiple processes to access and manipulate a single stream of data.

Midi Kit
This kit provides a set of classes that know how to decipher and construct MIDI messages and that can listen to and broadcast to the built-in MIDI ports.

Kernel Kit
This is a C-based kit, allowing application threads low-level access to kernel services.

Device Kit
This kit provides a generalized interface for building drivers that extend the capabilities of the kernel - such as hardware drivers, graphics drivers and others. It also includes such objects as BSerialPort.

Network Kit
The Network Kit provides TCP/IP services based on the Berkeley Sockets (BSD) model. It also provides a class and functions that know how to send and receive e-mail.

3D Kit
The 3D Kit offers a 3-D rendering engine and classes with which a developer can easily construct and manipulate interactive 3-D graphics. This also incorporates support for the OpenGL® API standard.


Software Development

Software designed for the BeOS is highly modular, and in most cases allows for the dynamic loading and unloading of modules as needed. Software designed for the BeOS generally falls into one of four categories:

Application Software. Application software can be graphically based or command-line based (as described below). All applications are multithreaded, a capability inherent through the use of the Be software kits. Most applications will also create threads of their own.

Shared Libraries. Executable code can be placed in shared libraries, allowing multiple applications and processes to share common code, and reducing overall memory footprint. The BeOS itself makes use of shared libraries, resulting in significantly smaller application sizes than in traditional OS architectures.

Add-On Components. Also known as "plug-ins," the BeOS provides a standard architecture for software add-ons that extend the functionality of an application or driver. Add-ons can be dynamically loaded and unloaded as needed.

Drivers. Usually associated with hardware, drivers extend the BeOS kernel and OS servers to enable access to new hardware, network, and graphics capabilities. Drivers are also dynamically loaded and unloaded as needed.


Development Environment

A fast, object-oriented operating system provides the foundation for building high-performance, highly interactive applications. But that foundation is wasted without the right software development tools to take advantage of the capabilities.

That's why Be partnered with Metrowerks early in the BeOS development process to deliver the CodeWarrior integrated development environment native for Be systems. The award-winning CodeWarrior environment complements the tools already built-in to Be systems, allowing programmers to build GUI and command-line applications, shared libraries, and add-on components of any size. The familiar CodeWarrior features are there -- and more. CodeWarrior for the BeOS includes a multithreaded IDE that supports concurrent compilation -- taking advantage of multiple processors to speed application building.

  • Support for C++ templates and zero-overhead exception handling
  • Multiple inheritance and RTTI support
  • Global optimization for PowerPC and Intel C/C++ compilers
  • Metrowerks Standard Library (MSL) for C, includes source code
  • Sample code
  • Command-line tools for generating resources


Command-Line Environment and Posix

Designed in from the start, the BeOS provides a command-line shell environment based on the UNIX Bourne-Again Shell (bash) -- in addition to the native graphical environment. Many programmers find that they can be more productive during the development process using a command-oriented environment -- and a wide variety of programming tasks can only be accomplished from a text-based shell. The command-line shell can be accessed at any time by launching the Terminal application, and multiple shells can be invoked simultaneously.

In addition, the BeOS goes a step further by providing a Posix-compliant layer within the operating system. This library allows a wide array of UNIX shell tools to be compiled and run on the BeOS without change. The BeOS comes with over one hundred of these tools already installed, and more are being ported by Be and by third parties every day.


Leveraging Standards

Although the BeOS represents a fresh start in OS design, we'd be foolish not to leverage many of the key standards the software industry has adopted for functionality, from typeface design, to networking software, to the latest in multimedia formats. The BeOS incorporates standards such as TCP/IP networking and Internet protocols for a wide variety of network-based services, TrueType and PostScript font technology, Posix and standard UNIX tools, MIDI musical data formats, MPEG and QuickTime video format support, and many other standards from across the industry. In each of these examples, we've taken the best the industry has to offer and incorporated it cleanly and effectively into the BeOS environment.


Demand and Distribution
In delivering a product to market, software developers have to face the three "Ds" -- development, demand creation, and distribution. They must address all three for their products to succeed. Our goal at Be is to aid developers in maximizing the opportunity for software that uses the BeOS as a platform, while minimizing costs and speeding time-to-market. To that end, Be has put into place a range of programs that will aid developers in each stage of bringing a product to market.


Be Developer Programs

The Be Developer Programs are designed to give developers access to the tools and information they need to get new software up and running. There are three programs, each with benefits aimed at their target audiences: enthusiasts, professional developers (including "midnight programmers" moonlighting on the BeOS) and commercial development projects. Benefits of the programs include:

  • Immediate notice of the latest Be products and technology announcements through electronic mail and through the Be web site.
  • Fast delivery of new versions of the Be Operating System for development purposes, and early notice of the features planned for future releases.
  • Access to Be developer support resources to answer technical questions and connections to others in the Be development community. Through developer support, developers have access to the Be engineering team to solve OS problems and suggest changes for future versions of Be products.
  • Be Developer Conferences, Developer Kitchens, tutorials, seminars, a wide range of Be publications and access to joint promotional programs. For more information, visit the Developer section of the Be web site.

The Be Developer Programs have no complex qualification processes, and are priced very attractively, including a free enthusiast program.



Traditional distribution models, which carry significant risk and require considerable up-front capital for catalog advertising and for building retail infrastructure, have long been recognized as a factor in limiting the introduction of new technologies and ideas.

But the world of software distribution is changing, and, in the process, is opening horizons of opportunity for developers. How? The Internet enables delivery of detailed information about products, downloading of demo versions of software, and can provide extensive support for customers. It can even deliver products directly to the customer's personal computer. And the Internet can provide support for hybrid distribution programs that include traditional distribution channels.

From its inception, Be has leveraged the Internet for communication with developers and customers, for developer support, and for developer and customer sales and distribution. Be has built on this initial Web site foundation to provide a single location where all Be customers can turn for support, for information about the latest from Be, and for the latest information about third-party products. We provide a range of options developers can choose from -- from simple hyperlink connections to purchase transaction completion. Through its BeDepot business, Be offers developers a turnkey solution for selling products, both physical and electronic. Through the Be site, developers have regular access to Be customers, and customers have a central place to turn for information and support for total solutions -- a win-win situation overall.



In addition to the programs described above, Be offers a range of comarketing opportunities to developers -- from access to the Be Internet site, to demo placement on software CDs, to joint efforts targeting vertical markets. The core of the identity campaign for Be-compatible software revolves around the Be web site, and the BeWare software mark, which any developer who produces Be-compatible software can use.


Why Develop for Be?

The decision to develop software or hardware for any platform involves evaluating a wide range of factors, including the ability to reach potential customers, the complexity of development, the cost of distribution, and possibly the most important factor: The ability to bring to market new, innovative ideas that would not otherwise be possible. As developers make plans for their next cutting-edge applications, Be offers a number of things to consider:

A New Technology Base. The BeOS provides a cutting-edge foundation for designing software that will fulfill the needs of the next decade's applications -- applications that involve extensive real-time media, complex graphics, and intensive communication capabilities. It jettisons much of the baggage associated with other mainstream operating systems, while retaining compatibility with key data and networking standards such as MPEG, TCP/IP, and MIDI. The BeOS delivers workstation-level performance at mainstream PC price points and provides an object-oriented environment compact enough for developers to be highly efficient, reducing time-to-market.

A New Business Model. The Be system presents a new business model for developers -- a model that delivers wider and more direct exposure to customers than traditional models. A model that eliminates distribution overhead and focuses on electronic delivery for wide reach, aided by informed, knowledgeable resellers focused on vertical markets. A model that delivers wide customer reach while reducing overall costs of distribution.

A Dedicated Partner. Since day one, Be has recognized that our success depends upon the success of our developers. It's the development community that will translate the power inherent in the BeOS into power usable by individual customers. For this reason, we have focused on making the BeOS environment as productive as possible for developers, and we're working to provide a complete, cost-effective business model for Be-compatible products. We're committed to continuing this dedication -- and partnership -- in the future.

We're confident that the Be architecture delivers a fresh and exciting alternative for developers who are frustrated by the limitations of today's computing architectures. We invite developers to take the next step by contacting us to find out more about Be products, and about becoming an official Be developer.

The BeOS News and Events Developers User Groups Support BeStore BeWare
Copyright ©1998 Be, Inc. Be is a registered trademark, and BeOS, BeBox, BeWare, GeekPort, the Be logo and the BeOS logo are trademarks of Be, Inc. All other trademarks mentioned are the property of their respective owners. Comments about this site? Please write us at Icons used herein are the property of Be Inc. All rights reserved.