TweetFollow Us on Twitter

August 91 - Macintosh Common Lisp and CLOS

Macintosh Common Lisp and CLOS

Jeffrey W. Stulin

This article is the first in a series of three on Macintosh Common Lisp (MCL) and Common Lisp Object System (CLOS).

MCL is worth learning about, even for those of you who don't think you'll use it-because it's likely that there will eventually be Macintosh object programming environments and operating systems to come that are based upon technology strongly influenced by Lisp.

This first article introduces the MCL series, and presents a basic Lisp tutorial. The second article will discuss the MCL environment and tools, and introduce CLOS. The third article will present an MCL version of the author's MacApp sample program Game Of Life, and discuss how developing Life in MCL was different than developing it in MacApp and Pascal.

Macintosh Common Lisp 2.0b1 (MCL) offers a refreshingly different approach to software prototyping and development. In this series of three articles, I'll describe the feel of development using MCL, and explore how MCL development can lead to a lower "cost of innovation" than development using MPW and MacApp.

AN author's dilemma

The classic approach of showing a language is to compare its syntax and features with those already known by the reader. Alas, Lisp has almost no syntax. Even if it did, that approach would be a dismal failure. What makes Lisp interesting is its "feel of development," which has no equivalent in Pascal or C++.

Do you remember first learning about object programming? How many times did you have to hear about classes, instances, and inheritance before the concepts behind the words finally took root? Do you truly understand them, or are there still things for you to learn?

Lisp concepts are even more different than the concepts of object programming. A new vocabulary filled with subtle connotations must be mastered. This can't be done by reading a formal specification of the language. (Not to mention that the current definition of Lisp is contained in a 1000 page book with a 10-point typeface.)

So my dilemma is this: do I take the safe route and compare Lisp syntax to that of Pascal, or do I live dangerously, and try to present the "feel" of Lisp instead of Lisp itself?

Since "feel" is subjective, I would risk accusations of language bigotry and unprofessionalism. Perhaps even have my articles rejected. How embarrassing. Oh, well. Life is short.

This first article is philosophical. It introduces the series, presents the concept of "cost of innovation," explains (without yet proving) that Lisp provides a much lower cost of innovation than MPW and MacApp, presents a basic Lisp tutorial, and concludes with a guide and bibliography on how to learn Lisp.

The second article in the series will be more concrete. It will present additional Lisp concepts, discuss the MCL development environment and tools (editor, debuggers, etc.), and present CLOS, the Common Lisp Object System.

The third article will pull everything together. It will present the sample program Game Of Life and discuss how developing Life in MCL was different than in Pascal and MacApp. Both the development process and the quality of the final programs will be considered, and source code for both versions will be included on the FrameWorks Disk..

What is Lisp?

Lisp is the second oldest programming language still in use. It was developed by John McCarthy at MIT in the 1950's. Lisp was originally designed for problems in calculus, logic, game playing, and artificial intelligence.

Lisp rapidly evolved into incompatible dialects reflecting the needs of several organizations; for example, MacLISP at MIT, ZetaLisp for Lisp machines, and FranzLisp for Unix.

In 1984, a new dialect, Common Lisp, sought to create a portable, unified language on which further extensions could be built. Common Lisp was well received and is now working its way toward being an ANSI standard.

Many approaches to object programming have been implemented in Lisp. There has been much cross-fertilization between Lisp and SmallTalk. A standard object programming extension to Common Lisp, called Common Lisp Object System (CLOS), which includes many ideas from these earlier approaches, has recently been accepted as part of the forthcoming ANSI standard. CLOS is based on classes, multiple inheritance, generic functions, and methods. It will eventually include a meta-object protocol. CLOS's flexibility has to be seen to be believed.

Not everyone was happy with the standardization of Lisp. In particular, the fans of Scheme, a Lisp dialect oriented toward teaching, objected to several decisions incorporated in the standard. So it can be expected that other Lisp dialects will continue to be popular.

A few years ago, Apple acquired Coral Software, whose flagship product was a version of Lisp based on the 1984 Common Lisp standard. This was before CLOS, so Coral developed their own object programming standard, Object Lisp, with a Macintosh Class library built on top.

Apple has renamed the product Macintosh Common Lisp (MCL), replaced Object Lisp with CLOS, brought it up to the latest almost-ANSI standard, improved the class library, and released it in beta form, MCL 2.0b1. These articles are based on MCL 2.0b1.

Why Macintosh Common Lisp?

MCL offers a powerful environment for software development:
  • A complete implementation of Lisp as defined in [Steele 1990], including almost 1000 functions, macros and special forms.
  • CLOS, a uniquely flexible object programming paradigm.
  • A user interface class library.
  • The full set of Lisp data types, including linked lists, arrays, structures, objects and hash tables.
  • FRED, a Lisp-sensitive text editor.
  • Extensive debugging facilities, including single stepping, tracing, interactive break points, and extensive object inspection.

Most important, however, is the Lisp approach to software development. I will now explore two aspects of programming that show, by contrast, the Lisp approach. This is a theoretical exploration; specific examples demonstrating these points will be presented later.

The design approach

In university, computer science students are taught (or at least they used to be) that the correct way to develop a software project is from the top down. In top-down design, one starts with a description of the program and then breaks that into more manageable subproblems until each subproblem piece can be easily coded. Traditional languages encourage top-down development.

This approach assumes that while designing the top level we can ignore nasty realities about the bottom levels; that is, that the chosen abstractions will protect the program design from messy details.

Consider this painful counter-example from my past. In graduate school, I took a software engineering course. Its final project required us to develop a certain program. Computer facilities consisted of an IBM computer with punched card input and PL/C, a teaching version of PL/1.

My project required a stack of punched cards almost a foot high. I started debugging at 10 a.m. the day before it was due. At 11 a.m., I had finished debugging individual program components and was ready to put it all together. I figured on being done by lunch. Ten frustrating hours later, I finally traced a program bug down to the fact that PL/C did not handle subroutine parameter passing the same way as PL/1. My entire design required this missing feature. I had to throw away my foot of cards, redesign, retype, and re-debug the program; I was not happy.

Low level details can doom designs; so, in reality, programs must be developed both from the top down and the bottom up. Top down to allow for consistency and clarity of design, and bottom up to test that things work as expected in terms of both functionality and performance.

Bottom-up development is a "bits and pieces" approach; you want to exercise a certain program part quickly and in isolation from the rest of the program. Also, bottom up is where a lot of innovation comes from. It is low level "tinkering" with the toolbox and Macintosh hardware that's exciting, and that inspires me to explore new ways of doing things.

Neither Pascal nor C++ makes "bits and pieces" development easy. Pascal and C++ programs are centered around a "main" block or function which imposes a hierarchical ordering. It's difficult to test a program feature in isolation.

Assume you are in the late stages of developing a substantial C++ and MacApp program and you have a brainstorm, possibly a better way to represent program data. How can you experiment with this idea?

There are two choices. One is to incorporate your new idea in the current program. Since the program is hierarchical, you must rip out the old code, develop a fairly complete implementation of the new code, and hook it up. Even in a well designed modular system this could take considerable effort, just to test an idea that might not fly.

The second choice is to create a separate program to test out the idea. Setting up a new program is costly under both MPW and Think. Additionally, the new data representation may require part of the original program code to test. The code must be incorporated piecemeal in the new program, a confusing and time consuming operation.

A Lisp program has no conventionally imposed hierarchical ordering. There is no "main" function. A new data representation could easily be prototyped and tested in the current program environment without bothering the working code. If successful, it can be easily integrated. If not, it can be just as easily discarded. Thus there is no penalty for exploring new ideas.

Turn-around time

Consider another contrived example. Assume you are developing a large program. Part of this program displays a window with a square drawn in it. For some reason, you want to know what it would look like with a circle instead. (I chose this example because it explores the "cost" of a trivial experiment.)

On the IBM system described above, you would have to terminate the program, grab your deck of cards, find the card that drew the square, repunch the card, schedule time to use the graphics room, place the cards in the hopper, walk into the graphics room, and wait for your program to be run. Average turn around would be about 24 hours.

On a Macintosh with MPW, you would terminate the program, return to MPW, find the correct DrawContents method, change a line from FrameRect(r) to FrameOval(r), rebuild the application, rerun it, and view the result. Turn around would be five minutes or so.

In Think Pascal with MacApp, you would reset the program, find the proper method, make a similar change, rebuild, and rerun the application. Turn around would be a minute or two.

In MCL, you would click on the editor window, scroll to the ViewDrawContents method, change a line from (draw-rect r) to (draw-circle r), reevaluate only that one method, and immediately observe the new behavior in the same window that previously drew the square. Turn around time would be about ten seconds.

Think compilers achieve quick turn around by closely integrating the development tools, the development environment, and the running environment. This effectively blurs the distinction between developing and running a program.

MCL eliminates this distinction. Windows, objects, and functions created by the user even while your program is running are available immediately after creation. They run as first-class objects next to MCL's own. There is no time consuming context switching between development and execution.

Furthermore, MCL offers an incrementally compiled environment. After a function is written, it can be compiled and linked into your development environment instantaneously. No damned spinning beach ball to watch.

The cost of innovation

The cost of innovation is my term for the difficulty of trying out an idea. Trying out an idea requires a language to express the idea and a development environment to give it life. The language and the environment cannot be separated. Assume your choice for a project is either C++ on the above described IBM system, or Pascal and MacApp on a Macintosh. Wouldn't even the most rabid C++ fanatic choose Pascal in that case?

MCL wins in both language and environment areas (well… almost). It is a more expressive language than Pascal or C++. Its development tools are complete and very, very quick. It supports top down, bottom up, side to side, right to left or whatever type of design methodology your program requires. Other aspects of MCL further reducing the cost of innovation will be demonstrated later.

So why doesn't everybody program in Lisp?

Why not Macintosh Common Lisp?

Currently, it isn't practical to deliver applications in MCL. Major reasons include performance, memory requirements, and incompleteness of the MCL class library. These and other negative aspects of MCL will be discussed in subsequent articles.

Despite this, don't give up on MCL. It has immediate potential as a superior prototyping tool, it can teach us much about software development, and it points the way to the future of development systems. Furthermore, despite Lisp's reputation as a slowpoke, performance of delivered applications is almost acceptable. One more round of hardware improvements may clinch it.

On a purely subjective note, MCL is in many ways a far more enjoyable and productive environment than any other I have used in 20 years of software experience.

A Basic introduction to Macintosh Common Lisp

While it isn't the goal of these articles to teach Lisp, I will present basic Lisp concepts here so subsequent discussions and code fragments can be understood. What follows is a very brief and shallow Lisp tutorial. I plead for your patience, and promise that subsequent articles will make this lengthy introduction worthwhile.

All program code and user input are shown in a plain font. All Listener responses are shown in bold.

Lisp basics

After you start MCL, a special window called the Listener prompts for input with a question mark. The Listener reads what you type, evaluates it, and prints its result. This is known as the read-eval-print loop. Every evaluated expression in Lisp produces a value. The Listener reads symbolic expressions (s-expressions). An s-expression is either an atom or a list. Atoms are things such as numbers or symbols. The value of a number is the number itself. Thus:
? 123.45
123.45

Symbols may have values. If the symbol my-bike has the value "Huffy", then:

? my-bike
"Huffy"

A list is a finite sequence of s-expressions surrounded by parentheses. Here are some lists:

(* (+ 3 4) (- 5 6))
(1 2 3)
(the cat (in the) hat)

When you enter a list, the Listener assumes the first item in the list is a function name and that all following items are arguments to that function. This is prefix notation. Thus:

? (* (+ 3 4) (- 5 6))
-7

A form is an s-expression that is to be evaluated. In the previous example, we typed the form (* (+ 3 4) (- 5 6)) into the Listener. When evaluating a function form, Lisp applies the function to its evaluated arguments. In this case, the function is *, the multiplication operation. Its arguments are two forms, (+ 3 4) and (- 5 6). These are evaluated and the results are passed to *. (+ 3 4) evaluates to 7, (- 5 6) to -1. Thus * is called with arguments of 7 and -1 resulting in -7, which is what the Listener prints. Note that lists are recursively defined, and that evaluation is also recursive.

You can give a value to a symbol via the setf macro.

? (setf my-bike "Ross")
"Ross"

The value of the setf macro is the value of the symbol being defined. In this case, we are defining my-bike to be "Ross".

? my-bike
"Ross"

When the first element of a list form is a function name, the listener evaluates its arguments before application. The two other types of list forms, macros and special forms, work differently.

We need special forms because we don't always want arguments evaluated. Assume we have a Lisp function, in-fix, that could evaluate an infix expression:

? (in-fix ((3 + 4) * (5 - 6)))
> Error: Car of ((3 + 4) * (5 - 6)) is not a function name or 
                                                  lambda-expression.
> While executing: 
CCL::CHEAP-EVAL-IN-ENVIRONMENT
> Type Command-. to abort.
See the Restarts… menu item for further choices.
1 > 

The problem is that Lisp will attempt to evaluate ((3 + 4) * (5 - 6)) before passing it to in-fix. Since Lisp assumes the first element of a form being evaluated is a function, and the first element of this list is another list, (3 + 4), Lisp signals an error.

What we want is to pass ((3 + 4) * (5 - 6)) unevaluated to in-fix. Lisp provides a special form, quote, which returns its unevaluated argument. This would work (after we develop in-fix, of course):

? (in-fix (quote ((3 + 4) * (5 - 6))))
-7

It's common to want to avoid evaluating an argument, so Lisp provides a shorthand notation for quote-a single quote character before a form:

? (in-fix '((3 + 4) * (5 - 6)))
-7

There are about 30 special forms. No more can be added. However, you can write Lisp macros that provide control over the evaluation of arguments. Macros are beyond the scope of these articles.

A list form can be either a macro, a special form, or a function call. The developer must memorize which is which. Understanding the distinctions between these list forms and the how and why of Lisp's evaluation rule is a difficult task for the beginner.

Lists

Lisp stands for List Processing. The most basic data structure in Lisp is the list. Lisp code is also constructed from lists. This fact is one of Lisp's most annoying and most powerful aspects. Beginning Lispers may consume many bottles of aspirin before Lisp's list notation becomes comfortable. But it eventually does.

The cons function (constructor) puts lists together:

? (cons 'a '(b c))
(a b c)

In this example, we added the atom a to the list (b c). Note the use of quote to delay evaluation. The result is the list (a b c).

You can also take lists apart. The car function returns the first element of a list; the cdr function returns the rest of the list (for historical reasons, some of Lisp's function names are distressingly non-mnemonic):

? (car '(a b c))
a
? (cdr '(a b c))
(b c)
? (cons (car '(a b c)) (cdr '(a b c)))
(a b c)

Note how cons, car and cdr are related. I'll cover Lisp's extensive list handling forms as needed.

User -defined functions

The defun macro allows us to define new functions. Its simplified form is:
(defun function-name (list of parameters)
forms to be evaluated)

This function computes the average of three numbers:

(defun average-three (one two three)
(/ (+ one two three) 3))

A Lisp function body is a series of forms that are evaluated sequentially. The value of the function is the result of the last form. In this example, the body consists of one form (/ (+ one two three) 3) that adds the parameters together and divides by three.

First, we must tell Lisp about average-three by typing it in to the Listener:

? (defun average-three (one two three)
(/ (+ one two three) 3))
AVERAGE-THREE
? (average-three 7 8 9)
8
? 

Note that the value of a defun is the name of the function; a side effect is the association of the function with its name. In this case, we are more interested in defun's side effect than its value. After Lisp knows about average-three, it can be called like any pre-defined Lisp function.

Lisp is a naturally recursive language. We can easily write a function to return the number of elements of a list:

? (defun list-size (some-list)
  (if (null some-list)
    0
    (+ 1 (list-size (cdr some-list)))))
LIST-SIZE
? (list-size '(this is a short list))
5
? (list-size '(this list (has a sub) list))
4

A predicate is a function that returns true or false. The null predicate returns true when given an empty list. The if special form has this structure:

(if (test-form)
(then-clause)
(else-clause))
In this example, test-form is evaluated. If true, the then-clause is evaluated and its result becomes the result of the if. Else, the (optional) else-clause is evaluated and its result is used.

The function list-size can be described as follows: if some-list is empty, then return a zero, else return one plus the value of list-size applied to the rest of some-list. Thus list-size recursively traces through the list counting elements as it goes.

Note that list-size only counts elements in its top level; count-all-elements transverses all elements of the list:

(defun count-all-elements (some-list)
  (if (null some-list) 
    0
    (if (atom some-list)
      1
      (+ (count-all-elements (car some-list))
         (count-all-elements (cdr some-list)))))) 

The atom predicate returns true if given an atom (as opposed to a list). This can be read as: if some-list is empty, then return 0; else if some-list is an atom, then return one; else return the sum of count-all-elements applied to the first element of some-list plus count-all-elements applied to the rest of some-list. A recursive divide and conquer approach.

? (count-all-elements '((this list) has (sub) lists))
5

and even:

? (count-all-elements 
'(defun count-all-elements (some-list)
    (if (null some-list) 
    0
    (if (atom some-list)
      1
      (+ (count-all-elements (car some-list))
         (count-all-elements (cdr some-list)))))))
18

In this example, we give count-all-elements a listing of itself to process. Because data and programs are both represented as lists, and Lisp has many functions to manipulate lists, Lisp programs can be self-modifying. A Lisp program can take and modify pieces of itself on the fly, changing functions and adding new ones as needed. In fact, as you'll see when we explore CLOS, this self-modification is completely natural in Lisp!

Learning lisp-a road map

To learn Lisp, you must have Lisp. MCL is available from APDA for $495. This includes the works: Lisp, development tools, class libraries, CLOS, etc. Unfortunately, no student version of this excellent product is currently available.

Other versions of Lisp are also available. One is MacScheme, offering the Scheme dialect of Lisp instead of Common Lisp, by Lightship Software. A student version of MacScheme is available from the MIT Press for $37.50, including manual. I hope to evaluate MacScheme shortly.

An excellent Common Lisp tutorial for programmers is The Common Lisp Companion by Timothy Kroschmann from Wiley. This book is well written, up-to-date, covers large parts of the language, and presents numerous exercises with solutions.

Another tutorial is Lisp 3rd Edition by Patrick Henry Winston and Berthold Klaus Paul Horn, available from Addison Wesley. This book is geared more toward nonprogrammers and has an Artificial intelligence slant. It is a companion to Artificial Intelligence 2nd edition, also by Patrick Henry Winston.

Lisp, more than other languages, has many different ways of doing the same thing. Deciding which Lisp tools to use in solving a problem is especially overwhelming for the beginner. Lisp Design and Style by Molly M. Miller and Eric Benson, available from Digital Press, is an excellent book for these issues. Both the Kroschmann and Winston books deal incompletely with CLOS. A thorough treatment is presented in Object Oriented Programming in Common Lisp by Sonya E. Keene, available from Addison Wesley. This is not an easy book to read. However, after learning enough Lisp and CLOS to understand what was being said, I found myself exclaiming "It can really do that?" after reading each page.

All of the books mentioned above present simplified subsets of Lisp. Even together, they are incomplete. Common Lisp The Language, second edition by Guy L. Steele Jr., available from Digital Press, is the current definition of Common Lisp. This book is required for serious Common Lisp development. It is not a tutorial and is difficult for the beginner to follow. It is, however, the most amazing, and often amusing, language definition I have ever read.

The Winter 1991 issue of Apple's technical Journal develop contained an article, The Power of Macintosh Common Lisp by Ruben Kleiman. This article is more readable with some prior knowledge of Common Lisp. It briefly covers the MCL tools, compares the MCL class library with MacApp, and details the development of an application that uses the MCL class library. Source code and detailed explanations are available on the accompanying CD.

A fascinating book that every software developer should own is Structure and Interpretation of Computer Programs by Harold Abelson and Jay Sussman, available from MIT Press. This book uses Scheme to teach basic concepts in programming and computer science.

Finally, a real kick is the Lisp 1.5 Programmer's Manual , also from the MIT Press. This is the (still in print!) users manual from Lisp 1.5, one of the earliest implementations of Lisp. It was originally published in 1962, and is now in its 15th printing. It offers historic insights into Lisp and the computer science of the early sixties. n

 
AAPL
$106.98
Apple Inc.
-0.36
MSFT
$46.05
Microsoft Corpora
-0.57
GOOG
$550.31
Google Inc.
+0.98

MacTech Search:
Community Search:

Software Updates via MacUpdate

Cocktail 8.0.1 - General maintenance and...
Cocktail is a general purpose utility for OS X that lets you clean, repair and optimize your Mac. It is a powerful digital toolset that helps hundreds of thousands of Mac users around the world get... Read more
LibreOffice 4.3.3.2 - Free Open Source o...
LibreOffice is an office suite (word processor, spreadsheet, presentations, drawing tool) compatible with other major office suites. The Document Foundation is coordinating development and... Read more
VMware Fusion 7.0.1 - Run Windows apps a...
VMware Fusion allows you to create a Virtual Machine on your Mac and run Windows (including Windows 8.1) and Windows software on your Mac. Run your favorite Windows applications alongside Mac... Read more
OneNote 15.3.2 - Free digital notebook f...
OneNote is your very own digital notebook. With OneNote, you can capture that flash of genius, that moment of inspiration, or that list of errands that's too important to forget. Whether you're at... Read more
Audio Hijack Pro 2.11.4 - Record and enh...
Audio Hijack Pro drastically changes the way you use audio on your computer, giving you the freedom to listen to audio when you want and how you want. Record and enhance any audio with Audio Hijack... Read more
Iridient Developer 3.0.0 beta 3 - Powerf...
Iridient Developer (was RAW Developer) is a powerful image conversion application designed specifically for OS X. Iridient Developer gives advanced photographers total control over every aspect of... Read more
TextWrangler 4.5.11 - Free general purpo...
TextWrangler is the powerful general purpose text editor, and Unix and server administrator's tool. Oh, and also, like the best things in life, it's free. TextWrangler is the "little brother" to... Read more
NeoFinder 6.6 - Catalog your external me...
NeoFinder (formerly CDFinder) rapidly organizes your data, either on external or internal disks, or any other volumes. It catalogs all your data, so you stay in control of your data archive or disk... Read more
Chromium 38.0.2125.111 - Fast and stable...
Chromium is an open-source browser project that aims to build a safer, faster, and more stable way for all Internet users to experience the web. FreeSMUG-Free OpenSource Mac User Group build is... Read more
Default Folder X 4.6.11 - Enhances Open...
Default Folder X attaches a toolbar to the right side of the Open and Save dialogs in any OS X-native application. The toolbar gives you fast access to various folders and commands. You just click... Read more

Latest Forum Discussions

See All

Audio Defence : Zombie Arena (Games)
Audio Defence : Zombie Arena 1.0 Device: iOS Universal Category: Games Price: $4.99, Version: 1.0 (iTunes) Description: A zombie shooter audio game. Made from gut-wrenching 3D binaural sound, for a new kind of weird immersion. You... | Read more »
RPG Asdivine Hearts (Games)
RPG Asdivine Hearts 1.1.0 Device: iOS Universal Category: Games Price: $3.99, Version: 1.1.0 (iTunes) Description: SPECIAL PRICE50% OFF (USD 7.99 -> USD 3.99)!!! Travel alongside four companions and a cat in the adventure of a... | Read more »
Haunt the House: Terrortown (Games)
Haunt the House: Terrortown 1.0.1 Device: iOS Universal Category: Games Price: $.99, Version: 1.0.1 (iTunes) Description: 66.6% OFF! SPECIAL SPOOKY HALLOWEEN LAUNCH PRICE! 66.6% OFF! ...What was that sound? Is somebody there? | Read more »
SAS: Zombie Assault 4 Review
SAS: Zombie Assault 4 Review By Jennifer Allen on October 30th, 2014 Our Rating: :: FLAWED SHOOTERUniversal App - Designed for iPhone and iPad Shoot everything that moves in this fun, if flawed, twin-stick shooter.   | Read more »
Naailde the Witch Review
Naailde the Witch Review By Amy Solomon on October 30th, 2014 Our Rating: :: PITCH-PERFECT STORYTELLINGUniversal App - Designed for iPhone and iPad Marvelous storytelling, narration, and moving illustrations make this storybook... | Read more »
1st & Goal Review
1st & Goal Review By Andrew Fisher on October 30th, 2014 Our Rating: :: FOR THE D&D LOVING QBUniversal App - Designed for iPhone and iPad 1st & Goal is a board gamer’s football game, a football fan’s board game, and... | Read more »
French Developer Pated Unveils Seashine
French Developer Pated Unveils Seashine Posted by Ellis Spice on October 30th, 2014 [ permalink ] French one-man studio Pated has unveiled Seashine, “a poetic journey into the abyss.” Players take on the role of a jellyfish strugglin | Read more »
Agents of Storm: Tips, Tricks, and Strat...
Calling all agents: Would you like to see what we thought of this rather pretty base builder? Check out our Agents of Storm review! Have you downloaded Agents of Storm, been bowled over by the graphics, and aren’t quite sure what to do next? Never... | Read more »
Any.DO 2.0 Hopes to Help Manage Producti...
Any.DO 2.0 Hopes to Help Manage Productivity Posted by Ellis Spice on October 30th, 2014 [ permalink ] iPhone App - Designed for the iPhone, compatible with the iPad | Read more »
Base Busters Review
Base Busters Review By Jennifer Allen on October 30th, 2014 Our Rating: :: FUN BUT RESTRICTED MIXUniversal App - Designed for iPhone and iPad Mixing up two forms of tower defense gaming and collectible cards, Base Busters is a fun... | Read more »

Price Scanner via MacPrices.net

Apple Regains Momentum As Windows Stutters An...
The latest smartphone sales data from Kantar Worldpanel ComTech, for the three months to March 2014, shows Apple performing strongly in the first quarter of the year, with sales bouncing back in... Read more
Worldwide Smartphone Shipments Increase 25.2%...
New smartphone releases and an increased emphasis on emerging markets drove global smartphone shipments above 300 million units for the second consecutive quarter, according to preliminary data from... Read more
Apple now offering refurbished 2014 15-inch M...
The Apple Store is now offering Apple Certified Refurbished 2014 15″ Retina MacBook Pros for up to $400 off the cost of new models. An Apple one-year warranty is included with each model, and... Read more
Apple drops prices on refurbished 2013 Retina...
The Apple Store has dropped prices on 2013 Apple Certified Refurbished 13″ and 15″ Retina MacBook Pros, with Retina models now available starting at $999. Apple’s one-year warranty is standard, and... Read more
New 2.8GHz Mac mini on sale for $949, save $5...
Abt Electronics has the new 2.8GHz Mac mini in stock and on sale for $949.05 including free shipping. Their price is $50 off MSRP, and it’s the lowest price available for this model from any reseller... Read more
Sale! 3.7GHz Quad Core Mac Pro available for...
 B&H Photo has the 3.7GHz Quad Core Mac Pro on sale for $2649 including free shipping plus NY sales tax only. Their price is $350 off MSRP, and it’s the lowest price for this model from any... Read more
Mujjo Steps Up The Game With Refined Touchscr...
Netherlands based Mujjo have just launched their Refined Touchscreen Gloves, stepping up their game. The gloves feature a updated elegant design that takes these knitted gloves to the next level. A... Read more
Sale! Preorder the new 27-inch 5K iMac for $2...
 Abt Electronics has the new 27″ 3.5GHz 5K iMac on sale and available for preorder for $2374.05 including free shipping. Their price is $125 off MSRP, and it’s the lowest price available for this... Read more
Simplex Solutions Inc. Brings Secure Web Surf...
New York based Simplex Solutions Inc. has announced the release and immediate availability of Private Browser 1.0, its revolutionary new secure web browser developed for iPhone, iPad and iPod touch... Read more
Save up to $180 off MSRP with an Apple refurb...
The Apple Store has Apple Certified Refurbished 2014 MacBook Airs available for up to $180 off the cost of new models. An Apple one-year warranty is included with each MacBook, and shipping is free.... Read more

Jobs Board

Position Opening at *Apple* - Apple (United...
**Job Summary** Every day, business customers come to the Apple Store to discover what powerful, easy-to-use Apple products can do for them. As a Business Leader, Read more
Sr. Manager, *Apple* Deployment Programs fo...
**Job Summary** Apple is seeking candidates for a new position on the Education Content and Technology team. iPad and Mac is in the hands of millions of teachers and Read more
*Apple* Solutions Consultant (ASC) - Apple I...
…important role that the ASC serves is that of providing an excellent Apple Customer Experience. Responsibilities include: * Promoting Apple products and solutions Read more
*Apple* Solutions Consultant (ASC) - Apple I...
…important role that the ASC serves is that of providing an excellent Apple Customer Experience. Responsibilities include: * Promoting Apple products and solutions Read more
*Apple* Solutions Consultant (ASC) - Apple I...
…important role that the ASC serves is that of providing an excellent Apple Customer Experience. Responsibilities include: * Promoting Apple products and solutions Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.