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
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 -- 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.
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
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
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
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
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
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
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
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
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
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.
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
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 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
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
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:
Contains core application objects, such as BApplication, BMessage (for
communications), and BLooper (for creating new threads).
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.
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
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
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
This is a C-based kit, allowing application threads low-level access
to kernel services.
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.
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.
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 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
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
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.
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
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.