Thread Viewer

Thread Viewer is a performance tool which graphically displays activity across a range of threads. It provides color-coded time-line views of thread activity and can display backtraces of activity at specific points in time.

Spin Control

Spin Control is a performance tool used for monitoring hang activity in software programs. The program gets its name from the Spinning wait cursor, which is a "spinning wheel" on OS X.^[2]

Shark

Shark is a profiler, used by software developers to optimize software programs on Mac OS X. It samples software at set time intervals (or driven by hardware performance monitors events) taking snapshots of the stack, showing the functions which require more of the application’s resources. Includes tools to analyze the data produced by a sampling run.

Repeat After Me

Optimizes the performance of the built-in text-to-speech software for Mac OS X. Tests the operating system's phonemic translation engine, creates graphs of the generated tone, to visually adjust the intonation, and records samples for reference.

Quartz Composer

A visual programming language for processing and rendering data. Using OpenGL, Core Image, Core Video, and other technologies to build an API and serves as a simple visual programming paradigm. Quartz Composer is a core technology of the Mac OS X. Quartz Composer creations work in any QuickTime-aware application (beginning with Mac OS X v10.4), from the Quartz Composer application, or embedded into Cocoa or Carbon applications.

Quartz Composer has many similarities to Max/MSP although its primary usage is for graphical rather than audio processing. Offers the ability to construct interactive video compositions that react to audio or MIDI signals and can be played from any QuickTime aware application.

Pixie

A magnifying glass application for magnifying small sections of the computer's screen, centered around the mouse cursor, giving the user a detailed view of the screen, as well as the pixel coordinates of the mouse. Provides several levels of zoom, "locking" the image under the mouse for closer examination, and saves the magnified image one of several formats. Helps ensure visual elements are aligned precisely.

An alternative for the Pixie app that comes in the default OS X installation is the DigitalColor Meter app in the Applications / Utilities folder. There is also a built-in zoom function enabled via System Preferences / Universal Access / Seeing which can enlarge the screen up to 20 times, but it provides no data about the pixels. The default way to activate this is Command-Option-Shift-= (in other words Command-Option-+), assuming the default keystrokes are enabled in System Preferences / Keyboard & Mouse / Keyboard Shortcuts.

PackageMaker

Creates application .pkg installer bundles for installing applications using the Installer application.

OpenGL Profiler

This tool assists developers in debugging and optimizing OpenGL usage under Mac OS X.
Supported features:
Launch or attach to an application
Breakpoints and execution control
Error detection including thread safety checks
Scripts
Buffer views
Resource viewing/editing
Statistics gathering
OpenGL call traces with stack traces and timings

OpenGL Driver Monitor

Real time access to the inner workings of the graphics processing unit. Runs locally or over a network using Bonjour which is less likely to interfere with the statistics it is gathering.

MallocDebug

Assistance for assessing memory usage and detecting memory leaks in programs.

Assesses an application's memory usage by monitoring a user as they interact with an application, which allows MallocDebug to build a memory profile.

Jar Bundler

Java tool that aids in packaging an application’s component files into a single double-clickable application. Properties can be modified to optimize the code.

IORegistryExplorer

Examines the Mac OS X hardware registry and offers a dozen view modes for data: unary, binary, octal, decimal, hexadecimal, ASCII,MacRoman, UTF-8 & Unicode; 8, 16, 32 & 64-bit; and big & little endian.

Icon Composer

Icon Composer is an icon editor that is part of the Apple Developer Tools. It does not have any editing features other than composing Apple Icon Image files and Windows ICO files. External editors must do all the image manipulation, then the results may be imported into the converter to create the finished icon.

icns Browser

Views the resources for an .icns file, displaying the Mini, Small, Large, Huge, Thumbnail & Tile sizes in all bit-depths and masks.

Help Indexer

Creates an index file for the Mac OS X built-in Help Viewer.

FileMerge

Similar to NEXTSTEP's Merge utility, it graphically compares and merges two different versions of a file, and is often used to track changes to source code.

A command line version is available through the Terminal application: opendiff.

CrashReporterPrefs

A developer utility for setting report parameters for Apple's Crash Reporter application.

• Basic: Shows a dialog asking the user what to do.
• Developer: Provides additional debug info and automatically shows the mail to Apple window.
• Server: Runs silent, but keeps all the logs.

Core Image Fun House

Used in testing Core Image units, which function similar to Adobe Photoshop filters. Each has a specific action, with parameters customize the action. Showcases Core Image, a technology introduced in Mac OS X v10.4, supported by newer graphic hardware.

Computer Hardware Understanding Development Tools

A set of software tools, collectively Computer Hardware Understanding Development Tools (CHUD Tools) measure software performance on Mac OS X, to aid in optimizing. Also provides hardware system benchmarks

Audio Unit Lab

A graphic presentation of audio units helping software developers to examine their results. AU Lab can be used to test audio units, conduct live mixing, and playback of audio content. Audio units are controlled visually with the audio unit’s graphic interface

Applet Launcher

A graphical interface for Sun’s Java Plug-in, which aids developers by demonstrating how Java applets perform on Mac OS X. Provides tools to adjust the performance & behavior applets in development

AppleScript Editor

An editor for AppleScript that is included with Mac OS X (was called Script Editor in versions of OS X prior to 10.6 Snow Leopard). Scripts are written into the document editing window and can be compiled and run from the Script Editor window. Scripts can also be saved as AppleScript applications (applets) or compiled scripts. Script Editor also provides access to a reference library of Apple Events dictionaries corresponding to the scriptable applications on your computer, and can log the Events and Results of scripts run from AppleScript Editor for debugging purposes.

Apple Developer Tools

The Apple Developer Tools are a suite of software tools from Apple to aid in making software titles for the Mac OS X platform. They come on the Snow Leopard installation CD as part of theXcode suite, but aren't installed by default.

Deadlocks

Deadlocks occur when two transactions each require data that the other has already locked exclusively. Deadlock detection is performed by the DBMS, which then aborts one of the transactions and allows the other to complete

Isolation

Isolation refers to the ability of one transaction to see the results of other transactions. Greater isolation typically reduces performance and/or concurrency, leading DBMSs to provide administrative options to reduce isolation. For example, in a database that analyzes trends rather than looking at low-level detail, increased performance might justify allowing readers to see uncommitted changes ("dirty reads".)

Lock types

Locks can be shared^[9] or exclusive, and can lock out readers and/or writers. Locks can be created implicitly by the DBMS when a transaction performs an operation, or explicitly at the transaction's request.

Shared locks allow multiple transactions to lock the same resource. The lock persists until all such transactions complete. Exclusive locks are held by a single transaction and prevent other transactions from locking the same resource.

Read locks are usually shared, and prevent other transactions from modifying the resource. Write locks are exclusive, and prevent other transactions from modifying the resource. On some systems, write locks also prevent other transactions from reading the resource.

The DBMS implicitly locks data when it is updated, and may also do so when it is read. Transactions explicitly lock data to ensure that they can complete without a deadlock or other complication. Explicit locks may be useful for some administrative tasks.^[10][11]

Locking can significantly affect database performance, especially with large and complex transactions in highly concurrent environments.

Granularity

Locks can be coarse, covering an entire database, fine-grained, covering a single data item, or intermediate covering a collection of data such as all the rows in a RDBMS table.

Locking

When a transaction modifies a resource, the DBMS stops other transactions from also modifying it, typically by locking it. Locks also provide one method of ensuring that data does not change while a transaction is reading it or even that it doesn't change until a transaction that once read it has completed.

Confidentiality

Law and regulation governs the release of information from some databases, protecting medical history, driving records, telephone logs, etc.

In the United Kingdom, database privacy regulation falls under the Office of the Information Commissioner. Organizations based in the United Kingdom and holding personal data in digital format such as databases must register with the Office.^[8]

Security

Database security denotes the system, processes, and procedures that protect a database from unauthorized activity.
DBMSs usually enforce security through access control, auditing, and encryption:
Access control manages who can connect to the database via authentication and what they can do via authorization.
Auditing records information about database activity: who, what, when, and possibly where.
Encryption protects data at the lowest possible level by storing and possibly transmitting data in an unreadable form. The DBMS encrypts data when it is added to the database and decrypts it when returning query results. This process can occur on the client side of a network connection to prevent unauthorized access at the point of use.

Replication

Database replication involves maintaining multiple copies of a database on different computers, to allow more users to access it, or to allow a secondary site to immediately take over if the primary site stops working. Some DBMS piggyback replication on top of their transaction logging facility, applying the primary's log to the secondary in near real-time. Database clustering is a related concept for handling larger databases and user communities by employing a cluster of multiple computers to host a single database that can use replication as part of its approach.^[6][7]

Transactions

Most DBMS provide some form of support for transactions, which allow multiple data items to be updated in a consistent fashion, such that updates that are part of a transaction succeed or fail in unison. The so-called ACID rules, summarized here, characterize this behavior:

Atomicity: Either all the data changes in a transaction must happen, or none of them. The transaction must be completed, or else it must be undone (rolled back).

Consistency: Every transaction must preserve the declared consistency rules for the database.

Isolation: Two concurrent transactions cannot interfere with one another. Intermediate results within one transaction must remain invisible to other transactions. The most extreme form of isolation is serializability, meaning that transactions that take place concurrently could instead be performed in some series, without affecting the ultimate result.

Durability: Completed transactions cannot be aborted later or their results discarded. They must persist through (for instance) DBMS restarts.

In practice, many DBMSs allow the selective relaxation of these rules to balance perfect behavior with optimum performance.

Indexing

Indexing is a technique for improving database performance. The many types of index share the common property that they eliminate the need to examine every entry when running a query. In large databases, this can reduce query time/cost by orders of magnitude. The simplest form of index is a sorted list of values that can be searched using a binary search with an adjacent reference to the location of the entry, analogous to the index in the back of a book. The same data can have multiple indexes (an employee database could be indexed by last name and hire date.)

Indexes affect performance, but not results. Database designers can add or remove indexes without changing application logic, reducing maintenance costs as the database grows and database usage evolves.

Given a particular query, the DBMS' query optimizer is responsible for devising the most efficient strategy for finding matching data. The optimizer decides which index or indexes to use, how to combine data from different parts of the database, how to provide data in the order requested, etc.

Indexes can speed up data access, but they consume space in the database, and must be updated each time the data are altered. Indexes therefore can speed data access but slow data maintenance. These two properties determine whether a given index is worth the cost.

Storage structures

Databases may store relational tables/indexes in memory or on hard disk in one of many forms:
ordered/unordered flat files
ISAM
heaps
hash buckets
logically-blocked files
B+ trees
The most commonly used^{[citation needed]} are B+ trees and ISAM.
Object databases use a range of storage mechanisms. Some use virtual memory-mapped files to make the native language (C++, Java etc.) objects persistent. This can be highly efficient but it can make multi-language access more difficult. Others disassemble objects into fixed- and varying-length components that are then clustered in fixed sized blocks on disk and reassembled into the appropriate format on either the client or server address space. Another popular technique involves storing the objects in tuples (much like a relational database) which the database server then reassembles into objects for the client.^{[citation needed]}
Other techniques include clustering by category (such as grouping data by month, or location), storing pre-computed query results, known asmaterialized views, partitioning data by range (e.g., a data range) or by hash.
Memory management and storage topology can be important design choices for database designers as well. Just as normalization is used to reduce storage requirements and improve database designs, conversely denormalization is often used to reduce join complexity and reduce query execution time.^[5]

Object database models

In recent years, the object-oriented paradigm has been applied in areas such as engineering and spatial databases, telecommunications and in various scientific domains. The conglomeration of object oriented programming and database technology led to this new kind of database. These databases attempt to bring the database world and the application-programming world closer together, in particular by ensuring that the database uses the same type system as the application program. This aims to avoid the overhead (sometimes referred to as theimpedance mismatch) of converting information between its representation in the database (for example as rows in tables) and its representation in the application program (typically as objects). At the same time, object databases attempt to introduce key ideas of object programming, such as encapsulation and polymorphism, into the world of databases.

A variety of these ways have been tried^{[by whom?]} for storing objects in a database. Some products have approached the problem from the application-programming side, by making the objects manipulated by the program persistent. This also typically requires the addition of some kind of query language, since conventional programming languages do not provide language-level functionality for finding objects based on their information content. Others^[which?] have attacked the problem from the database end, by defining an object-oriented data model for the database, and defining a database programming language that allows full programming capabilities as well as traditional query facilities.