TweetFollow Us on Twitter

The Road to Code: Getting Oriented

Volume Number: 23 (2007)
Issue Number: 10
Column Tag: The Road to Code

The Road to Code: Getting Oriented

Introduction to Object-Oriented Programming

by Dave Dribin

Introduction

So far in The Road to Code, we have gone over variables, functions, control statements, and dynamic memory allocation. Now it's time to start putting all these pieces of the puzzle together and go over one of the main tenets of modern computer programming: object-oriented programming. Remember that Apple's native programming language is called Objective-C, which provides object-oriented extensions to the C language. The kind of programming we have been doing in straight C is called procedural programming. Even though the C language uses functions, the academic name for these functions is procedures. Where the focus of procedural programming is on procedures and data structures, object-oriented programming focuses on objects. Since objects are an evolutionary extension to procedures and data structures, this article will cover using data structures in C. This will lay the groundwork for us to finally start writing Objective-C code in next month's article.

Data Structures

Throughout this article, we will be writing code that deals with geometric rectangles. This is not the sexiest topic, but it is often used as an introduction to object-oriented programming. The nice thing about rectangles is that everyone knows what they are, so they require very little explanation. Their properties also require only knowledge of simple arithmetic. In case your geometry is a bit rusty, here's a simple diagram of a rectangle in the Cartesian coordinate system:


Figure 1: Rectangle in the Cartesian coordinate system

From this diagram, we can note the four points that make up this rectangle:

The lower left point is (5, 5)

The upper left point is (5, 10)

The upper right point is (15, 10)

The lower right point is (15, 5)

From these four points, we know the four edges of this rectangle:

The left edge has an X-coordinate of 5

The bottom edge has a Y-coordinate of 5

The right edge has an X-coordinate of 15

The top edge has a Y-coordinate of 10

From these four edges, we can determine the width and height of the rectangle

The width is: right edge - left edge = 15 - 5 = 10 units

The height is: top edge - bottom edge = 10 - 5 = 5 units

Finally, from the width and height, we can calculate the area and perimeter:

The area is: width x height = 5 x 10 = 50 units

The perimeter is: (2 x width) + (2 x height) = 2x5 + 2x10 = 30 units

Even though these calculations are fairly simple to do without a computer, I'm going to walk us through writing a program to help us calculate the area and perimeter of rectangles. Rectangles are used a lot in computer graphics, so this is more than just a trivial example used to demonstrate a point. I promise.

Area Calculations

Here is a simple program that calculates the area from the four edges of the rectangle:

Listing 1: main.c Area calculation

#include <stdio.h>
int main(int argc, const char * argv[])
{
   float leftX = 5;
   float bottomY = 5;
   float rightX = 15;
   float topY = 10;
   float area;
   area = (rightX - leftX) * (topY - bottomY);
   printf("Area is: %.2f\n", area);
   
   return 0;
}

I snuck in one shortcut that we haven't covered before. I've assigned a value to a variable in its declaration. This saves us four lines of code, since we do not need to assign the variables separately. When assigning a value to a variable in its declaration, it is called initializing a variable. Apart from this shortcut, the rest is straightforward and the output when run is:

Area is: 50.00

We know from our manual calculations that this is correct. Even though the area calculation is fairly simple, if we wanted to do multiple area calculations, we would put this into a function to avoid possible duplication errors:

Listing 2: main.c Area function

#include <stdio.h>
float rectangleArea(float leftX, float bottomY, float rightX, float topY)
{
   return (rightX - leftX) * (topY - bottomY);
}
int main(int argc, const char * argv[])
{
   float leftX1 = 5;
   float bottomY1 = 5;
   float rightX1 = 15;
   float topY1 = 10;
   
   float leftX2 = 0;
   float bottomY2 = 0;
   float rightX2 = 4;
   float topY2 = 4;
   
   float area;
   area = rectangleArea(leftX1, bottomY1, rightX1, topY1);
   printf("Area 1 is: %.2f\n", area);
   
   area = rectangleArea(leftX2, bottomY2, rightX2, topY2);
   printf("Area 2 is: %.2f\n", area);
   
   return 0;
}

Providing Structure

In Listing 2, we have chosen to represent a rectangle as four different variables representing the four edges of a rectangle. It can get very cumbersome to declare four different variables for every rectangle we want to use. The C language provides a construct called structures that group together multiple variables into one package. Here's how we would declare a structure for our rectangle:

struct rectangle
{
   float leftX;
   float bottomY;
   float rightX;
   float topY;
};

We can declare a variable of this structure using the following syntax:

   struct rectangle rectangle;

This declares a variable named rectangle that is of type struct rectangle. It may seem a little weird to have a structure and variable with the same name, but this is perfectly legal and actually quite common. This is legal because the full name of the structure is "struct rectangle" so it's not ambiguous what "rectangle" refers to.

To use the elements of the rectangle, such as leftX and bottomY, you would put a period or dot between them. Thus to set the four edges of our rectangle as in Figure 1, we would use the following code:

   rectangle.leftX = 5;
   rectangle.bottomY = 5;
   rectangle.rightX = 15;
   rectangle.topY = 10;

Even though we can access the individual elements, the structure as a whole can be passed around as a single unit. We can change our function signature to take this structure:

float rectangleArea(struct rectangle r)
{
   return (r.rightX - r.leftX) * (r.topY - r.bottomY);
}

This function now takes a single argument, instead of four. Its type is struct rectangle. Also, the elements are accessed with dots, just as when we assigned to them. When we call this function, we pass just the structure variable:

   area = rectangleArea(rectangle);

Packaging up our rectangle as a structure provides us a few benefits, but there is one final change I'd like to go over.

Type Definitions

Declaring structures is every so slightly different than declaring a variable as int or float. You need to include both words "struct rectangle" in front of the variable name. If you leave off the word struct, the compiler will give you an error. However, the C language allows us to create our own types that are even more similar to internal types, such as int or float. We can define our own types using the typedef keyword. Thus, we could include this line after our structure declaration to define our own type called Rectangle:

typedef struct rectangle Rectangle;

The typedef keyword makes a new type called Rectangle that is an alias for the type struct rectangle. This allows us to use the word Rectangle to declare variables and function arguments, instead of the more verbose struct rectangle:

   Rectangle rectangle;

I vastly prefer using typedefs for structures. I find it makes the resulting code clearer with less extraneous words and is less error prone since I don't have to remember to use the struct keyword. I also like to use a capital letter for new type names. This simple convention makes it clear which words are types and which are variables without much thought. This is very handy when looking at code someone else wrote or even code you wrote a while back.

Because using a typedef with a structure is such a common idiom, we can combine the structure definition and type definition into one:

typedef struct
{
   float leftX;
   float bottomY;
   float rightX;
   float topY;
} Rectangle;

Because we are using a typedef, we don't need to give the structure itself a name (though that is legal). Combining this technique we can re-write Listing 2 as:

Listing 3: main.c Rectangle structure

#include <stdio.h>
typedef struct
{
   float leftX;
   float bottomY;
   float rightX;
   float topY;
} Rectangle;
float rectangleArea(Rectangle r)
{
   return (r.rightX - r.leftX) * (r.topY - r.bottomY);
}
int main(int argc, const char * argv[])
{
   Rectangle rectangle1;
   Rectangle rectangle2;
   float area;
   
   rectangle1.leftX = 5;
   rectangle1.bottomY = 5;
   rectangle1.rightX = 15;
   rectangle1.topY = 10;
   rectangle2.leftX = 0;
   rectangle2.bottomY = 0;
   rectangle2.rightX = 4;
   rectangle2.topY = 4;
   area = rectangleArea(rectangle1);
   printf("Area 1 is: %.2f\n", area);
   
   area = rectangleArea(rectangle2);
   printf("Area 2 is: %.2f\n", area);
   
   return 0;
}

We now have a rectangle structure and a function that uses the structure. This combination of a structure and functions that manipulate that structure is called a data structure. Thus, we have begun to write a rectangle data structure.

Multiple Source Files

So far, we have only used one source file, named main.c. But as programs get larger, you will want to split your program into multiple source files. This helps organize your code into logical blocks, and allows you to reuse code in multiple source files. For example, now that we have a data structure to represent a rectangle, we may want to use this in other parts of our program. The best way to solve this problem is by putting rectangleArea in its own source file.

When using multiple source files, the compiler combines all functions in all source files together in one program. The program starts execution with the main function. There is one catch: each function name must be unique. This means that there can be only one rectangleArea function definition across all source files. If two different source files define the same function, you will get a compiler error.

We can put the rectangleArea function in its own source file, say rectangle.c, but then we need a way for other source files, like main.c, to be able to use it. If we just try and call it inside main.c, the compiler will complain that it does not know about a type named Rectangle and a function named rectangleArea. You've already seen and used the solution to this problem: header files.

We've used header files to give us access to system functions like printf and malloc, but header files are not anything magic. We can easily create our own. To tell the compiler that a function named rectangleArea exists, we put this code into a header file, for example, rectangle.h:

Listing 4: rectangle.h

typedef struct
{
   float leftX;
   float bottomY;
   float rightX;
   float topY;
} Rectangle;
float rectangleArea(Rectangle r);

This code looks very similar to the code before the main function in Listing 3. It contains the structure declaration, just as before, but we do not include the body of the rectangleArea function. This body-less function is called a function declaration. It tells the compiler that there is function named rectangleArea somewhere in our program, and it shouldn't complain if someone tries to call it. You can declare a function multiple times, but you must define it only once. Of course we do need to put the body of the function somewhere, so we put it in it's own source file, named rectangle.c:

Listing 5: rectangle.c

#include "rectangle.h"
float rectangleArea(Rectangle r)
{
   return (r.rightX - r.leftX) * (r.topY - r.bottomY);
}

This contains our function definition, with the full body, but it also starts off with a #include line. This is necessary because the header contains the structure and type definition for Rectangle. Without the header file, the compiler wouldn't know what Rectangle was. This line is also similar to how we include the stdio.h header file, for printf. You'll notice that double quotes ("rectangle.h") are used instead of angle brackets (<stdio.h>). The general rule is that angle brackets are used to include system header files where double quotes are used to include user defined header files.

I haven't told you how to actually create a new source and header file in Xcode, but the procedure is quite painless. As you have probably noticed, on the left hand side of the Xcode window, you will see a Groups & Files list. If you open the disclosure triangles, you will see the various files of your project. In the Source group, you will see the file named main.c that we have been using so far.


Figure 2: Groups & Files list

To create a new source file, make sure that the Source group is highlighted as in Figure 2, because this is where we want the new source file to be placed. Then, select New File... from the File menu. This will open up a New File dialog box, as shown in Figure 3. Choose C File, under the BSD category, and click Next. Now you are prompted to enter the name of the new file, as shown in Figure 4, so type rectangle.c. You'll notice that by default Xcode will automatically create a header file named rectangle.h for you. Since this is what we want, leave that checked and click Finish. You should see two files added to your Sources group on the left hand side, as in Figure 5.


Figure 3: New File dialog


Figure 4: New C File dialog


Figure 5: New files added to Source group

If you click on these new files, your editor window will allow you to edit the contents of the selected file. Go ahead and edit rectangle.h and rectangle.c to match Listing 4 and Listing 5, respectively. Finally, we need to change main.c to use our new header file. We can replace the structure and function definition with the #include statement, as in Listing 6.

Listing 6: main.c using rectangle.h

#include <stdio.h>
#include "rectangle.h"
int main(int argc, const char * argv[])
{
   Rectangle rectangle1;
   Rectangle rectangle2;
   float area;
   
   rectangle1.leftX = 5;
   rectangle1.bottomY = 5;
   rectangle1.rightX = 15;
   rectangle1.topY = 10;
   rectangle2.leftX = 0;
   rectangle2.bottomY = 0;
   rectangle2.rightX = 4;
   rectangle2.topY = 4;
   area = rectangleArea(rectangle1);
   printf("Area 1 is: %.2f\n", area);
   
   area = rectangleArea(rectangle2);
   printf("Area 2 is: %.2f\n", area);
   
   return 0;
}

With our rectangle structure and function in its own header file, we can use it in other source files besides main.c, too. All we would need to do is include rectangle.h in this other file, and it could also calculate the area of rectangles. Because the code in rectangle.h allows other code to use our data structure, it is called the interface. And because the code in rectangle.c is where the actual function definition is, it is called the implementation. Separating the interface from the implementation gives us a lot of flexibility to reuse common code in different parts of the program.

Add Perimeter Calculations

With our reusable rectangle data structure in place, we can now add other functions that operate on the Rectangle structure. For example, to add a function that calculates the perimeter, modify rectangle.h to match Listing 7 and rectangle.c to match Listing 8.

Listing 7: rectangle.h with rectanglePerimeter

typedef struct
{
   float leftX;
   float bottomY;
   float rightX;
   float topY;
} Rectangle;
float rectangleArea(Rectangle r);
float rectanglePerimeter(Rectangle r);
Listing 8: rectangle.c with rectanglePerimeter
#include "rectangle.h"
float rectangleArea(Rectangle r)
{
   return (r.rightX - r.leftX) * (r.topY - r.bottomY);
}
float rectanglePerimeter(Rectangle r)
{
   return 2*(r.rightX - r.leftX) + 2*(r.topY - r.bottomY);
}

This adds a declaration for the rectanglePerimeter function to the interface and its definition to the implementation. An example of how we could use this in main.c is Listing 9.

Listing 9: main.c using rectanglePerimeter

#include <stdio.h>
#include "rectangle.h"
int main(int argc, const char * argv[])
{
   Rectangle rectangle;
   
   rectangle.leftX = 5;
   rectangle.bottomY = 5;
   rectangle.rightX = 15;
   rectangle.topY = 10;
   printf("Area is: %.2f\n", rectangleArea(rectangle));
   printf("Perimeter is: %.2f\n", rectanglePerimeter(rectangle));
   
   return 0;
}

If we were to run this program, the output would be:

Area is: 50.00
Perimeter is: 30.00

With the concepts of reusable data structures added to your toolbox, you are now one step closer to object-oriented programming. While the idea of reusable data structures in not unique to object-oriented programming, it is a primary concept. When we write our first Objective-C code next month, you will see what I mean.

Encapsulation

Even though our structure stores the four edges, both our area and perimeter calculation use the width and height of the rectangle. We may want to change our structure to store the lower left corner (leftX and bottomY) along with the width and height to make these calculations easier:

typedef struct
{
   float leftX;
   float bottomY;
   float width;
   float height;
} Rectangle;

This still allows us to represent any geometric rectangle, but we avoid recalculating the width and height over and over again. Now, we can re-write our functions to use these new structure elements:

float rectangleArea(Rectangle r)
{
   return r.width * r.height;
}
float rectanglePerimeter(Rectangle r)
{
   return (2*r.width) + (2*r.height);
}

There, much simpler! But a side effect of this is that we just broke our code in main.c. It's still trying to set rightX and topY, which no longer exist. What if we still want to create our rectangle using the edges? Rather than changing main to use width and height, let's create a new function that takes the four edges and initializes the new structure elements:

Rectangle rectangleInitWithEdges(float leftX, float bottomY,
   float rightX, float topY)
{
   Rectangle r;
   r.leftX = leftX;
   r.bottomY = bottomY;
   r.width = rightX - leftX;
   r.height = topY - bottomY;
   return r;
}

This means we have to change our main function as follows:

int main(int argc, const char * argv[])
{
   Rectangle rectangle;
   
   rectangle = rectangleInitWithEdges(5, 5, 15, 10);
   printf("Area is: %.2f\n", rectangleArea(rectangle));
   printf("Perimeter is: %.2f\n", rectanglePerimeter(rectangle));
   
   return 0;
}

This now gives us the best of both worlds. We can still create rectangle structures using the four edges, but we can more naturally calculate the area and perimeter. The height and width are calculated only once inside rectangleInitWithEdges. Notice that the main function now never accesses the structure's elements directly. It only uses functions defined in the interface to manipulate the structure. The implementation is now the only code that accesses the structure's elements. This kind of code organization, where only the implementation accesses a structure's elements is called encapsulation.

Encapsulation is a very good goal of software design. It gives data structure writers more freedom to implement their data structure without affecting the users of the data structure. In fact, because our rectangle data structure now uses encapsulation, we can change the structure back to the original with four edges, and our code in main.c will stay exactly the same! We would have to change our area and perimeter calculations, but those are internal details.

The truth of the matter is that programs are constantly changing over time. The programs we have been writing so far have been fairly trivial. But in real programs, you will be constantly making modifications, either to add features or fix bugs. Whenever you make changes, there is the possibility of introducing new bugs. Limiting the scope of those changes will make sure you introduce as few bugs as possible. It will also allow you to make changes faster, since less code will need to be modified.

Modifying Rectangles

Okay, so if users of rectangles should no longer access the structure directly, what's the proper way to modify the rectangle? To preserve our encapsulation, we should add functions to the interface that do this. If we wanted to change the right edge of our rectangle, we could write a function like this:

void rectangleSetRightX(Rectangle r, float rightX)
{
   r.width = rightX - r.leftX;
}

Unfortunately, this will not work. Remember from our article on pointers that function arguments are completely separate variables from the ones passed in. The same holds true even for structures. The compiler will make a copy of the rectangle structure, and this function operates on the copy of the rectangle. When function arguments are copied like this, it is called passing by value. To solve this, we can pass a pointer to the rectangle, which is called passing by reference, as such:

void rectangleSetRightX(Rectangle * r, float rightX)
{
   (*r).width = rightX - (*r).leftX;
}

When we change the first function argument to a pointer, we need to dereference the pointer inside the function. Thus, the syntax "(*r).width" dereferences the pointer and then accesses the structure element. When dereferencing pointers to structures, it is important to use parentheses around the pointer dereference, to avoid any ambiguity of what the star means. Because it is cumbersome to use parentheses, the C language provides a shortcut syntax for dereferencing structure pointers using an arrow syntax:

void rectangleSetRightX(Rectangle * r, float rightX)
{
   r->width = rightX - r->leftX;
}

The arrow syntax, which is really two characters, a dash followed by the greater than sign, "->", allows us to dereference a pointer to a structure and access an element using a cleaner syntax. With this modification, the function declarations in our header file become:

Rectangle rectangleInitWithEdges(float leftX, float bottomY,
   float rightX, float topY);
void rectangleSetRightX(Rectangle * r, float rightX);
float rectangleArea(Rectangle r);
float rectanglePerimeter(Rectangle r);

Notice that we sometimes pass the rectangle by value and sometimes by reference. This can be confusing to the user of our data structure. Since we must use a pointer for rectangleSetRightX, I'm going to change all of our functions to use pointers, for consistency:

void rectangleInitWithEdges(Rectangle * r,
   float leftX, float bottomY, float rightX, float topY);
void rectangleSetRightX(Rectangle * r, float rightX);
float rectangleArea(Rectangle * r);
float rectanglePerimeter(Rectangle * r);

I also took the liberty of changing rectangleInitWithEdges to take a pointer to a Rectangle, too. This is also more consistent with our other functions. In fact, now every function takes a Rectangle * as its first argument. This means we have to change main.c to use the ampersand (address of) operator:

Listing 10: main.c using pointers

#include <stdio.h>
#include "rectangle.h"
int main(int argc, const char * argv[])
{
   Rectangle rectangle;
   
   rectangleInitWithEdges(&rectangle, 5, 5, 15, 10);
   printf("Area is: %.2f\n", rectangleArea(&rectangle));
   printf("Perimiter is: %.2f\n", rectanglePerimeter(&rectangle));
   
   rectangleSetRightX(&rectangle, 20);
   printf("Area is: %.2f\n", rectangleArea(&rectangle));
   printf("Perimeter is: %.2f\n", rectanglePerimeter(&rectangle));
   
   return 0;
}

Our code is now very consistent looking. It also allows us to use dynamic memory allocation for the rectangle, too. If we wanted to only use pointers in our application, we could re-write this using:

Listing 11: main.c using dynamic memory allocation

#include <stdio.h>
#include <stdlib.h>
#include "rectangle.h"
int main(int argc, const char * argv[])
{
   Rectangle * rectangle;
   
   rectangle = malloc(sizeof(Rectangle));
   rectangleInitWithEdges(rectangle, 5, 5, 15, 10);
   printf("Area is: %.2f\n", rectangleArea(rectangle));
   printf("Perimeter is: %.2f\n", rectanglePerimeter(rectangle));
   
   rectangleSetRightX(rectangle, 20);
   printf("Area is: %.2f\n", rectangleArea(rectangle));
   printf("Perimiter is: %.2f\n", rectanglePerimeter(rectangle));
   
   free(rectangle);
   
   return 0;
}

We must now allocate the memory before initializing it using malloc, and then return the memory to the system when we are done using free to avoid a memory leak. Other than that, our code is identical to Listing 10. Notice that sizeof works on structures, too. Here are the complete final listings for rectangle.h and rectangle.c just to make sure we're looking at the whole picture:

Listing 12: Final rectangle.h

typedef struct
{
   float leftX;
   float bottomY;
   float width;
   float height;
} Rectangle;
void rectangleInitWithEdges(Rectangle * r,
   float leftX, float bottomY, float rightX, float topY);
void rectangleSetRightX(Rectangle * r, float rightX);
float rectangleArea(Rectangle * r);
float rectanglePerimeter(Rectangle * r);

Listing 13: Final rectangle.c

#include "rectangle.h"
void rectangleInitWithEdges(Rectangle * r,
   float leftX, float bottomY, float rightX, float topY)
{
   r->leftX = leftX;
   r->bottomY = bottomY;
   r->width = rightX - leftX;
   r->height = topY - bottomY;
}
void rectangleSetRightX(Rectangle * r, float rightX)
{
   r->width = rightX - r->leftX;
}
float rectangleArea(Rectangle * r)
{
   return r->width * r->height;
}
float rectanglePerimeter(Rectangle * r)
{
   return (2*r->width) + (2*r->height);
}

Conclusion

In summary, we've written a small rectangle data structure with its own interface and implementation files using proper encapsulation. Users of our data structure can use the interface functions to access properties of the rectangle, without accessing its internal structure elements. Combining structures and functions into reusable data structures with separate interface and implementation files like this is what object-oriented code is all about. So congratulations! You've actually been writing object-oriented code! Well, there is a bit more to object-oriented code than this, but we've learned about 75% of what makes object-oriented code so special. Next month, we will finally learn some Objective-C code, and you will see how Objective-C makes it even easier to write object-oriented code.


Dave Dribin has been writing professional software for over eleven years. After five years programming embedded C in the telecom industry and a brief stint riding the Internet bubble, he decided to venture out on his own. Since 2001, he has been providing independent consulting services, and in 2006, he founded Bit Maki, Inc. Find out more at http://www.bitmaki.com/ and http://www.dribin.org/dave/.

 

Community Search:
MacTech Search:

Software Updates via MacUpdate

Firetask Pro 4.2.2 - Innovative task man...
Firetask Pro uniquely combines the advantages of classical priority-and-due-date-based task management with GTD. Stay focused and on top of your commitments - Firetask Pro's "Today" view shows all... Read more
Bookends 13.4.3 - Reference management a...
Bookends is a full-featured bibliography/reference and information-management system for students and professionals. Bookends uses the cloud to sync reference libraries on all the Macs you use.... Read more
LibreOffice 6.4.5.2 - Free, open-source...
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
Thunderbird 68.10.0 - Email client from...
As of July 2012, Thunderbird has transitioned to a new governance model, with new features being developed by the broader free software and open source community, and security fixes and improvements... Read more
Firefox 78.0.1 - Fast, safe Web browser.
Firefox offers a fast, safe Web browsing experience. Browse quickly, securely, and effortlessly. With its industry-leading features, Firefox is the choice of Web development professionals and casual... Read more
BetterTouchTool 3.389 - Customize multi-...
BetterTouchTool adds many new, fully customizable gestures to the Magic Mouse, Multi-Touch MacBook trackpad, and Magic Trackpad. These gestures are customizable: Magic Mouse: Pinch in / out (zoom)... Read more
Slack 4.7.0 - Collaborative communicatio...
Slack brings team communication and collaboration into one place so you can get more work done, whether you belong to a large enterprise or a small business. Check off your to-do list and move your... Read more
OsiriX Lite 11.0.3 - 3D medical image pr...
OsiriX Lite is an image processing software dedicated to DICOM images (".dcm" / ".DCM" extension) produced by medical equipment (MRI, CT, PET, PET-CT, ...) and confocal microscopy (LSM and BioRAD-PIC... Read more
Wireshark 3.2.5 - Network protocol analy...
Wireshark is one of the world's foremost network protocol analyzers, and is the standard in many parts of the industry. It is the continuation of a project that started in 1998. Hundreds of... Read more
Dabble 1.6.1 - Organize your manuscript,...
Dabble organizes your manuscript, story notes, and plot. Dabble simplifies the story, leaving more room in your brain to create, which is what being a writer is really about. Organize your story.... Read more

Latest Forum Discussions

See All

Pokemon Go's July Community Day wil...
Pokemon Go developers have announced the details concerning the upcoming Gastly Community Day. This particular event was selected by the players of the game after the Gas Pokemon came in second place after a poll that decided which Pokemon would... | Read more »
Clash Royale: The Road to Legendary Aren...
Supercell recently celebrated its 10th anniversary and their best title, Clash Royale, is as good as it's ever been. Even for lapsed players, returning to the game is as easy as can be. If you want to join us in picking the game back up, we've put... | Read more »
Detective Di is a point-and-click murder...
Detective Di is a point-and-click murder mystery set in Tang Dynasty-era China. You'll take on the role of China's best-known investigator, Di Renjie, as he solves a series of grisly murders that will ultimately lead him on a collision course with... | Read more »
Dissidia Final Fantasy Opera Omnia is se...
Dissidia Final Fantasy Opera Omnia, one of Square Enix's many popular mobile RPGs, has announced a plethora of in-game events that are set to take place over the summer. This will include several rewards, Free Multi Draws and more. [Read more] | Read more »
Sphaze is a neat-looking puzzler where y...
Sphaze is a neat-looking puzzler where you'll work to guide robots through increasingly elaborate mazes. It's set in a visually distinct world that's equal parts fantasy and sci-fi, and it's finally launched today for iOS and Android devices. [... | Read more »
Apple Arcade is in trouble
Yesterday, Bloomberg reported that Apple is disappointed in the performance of Apple Arcade and will be shifting their approach to the service by focusing on games that can retain subscribers and canceling other upcoming releases that don't fit... | Read more »
Pixel Petz, an inventive platform for de...
Pixel Petz has built up a sizeable player base thanks to its layered, easy-to-understand creative tools and friendly social experience. It revolves around designing, trading, and playing with a unique collection of pixel art pets, and it's out now... | Read more »
The King of Fighters Allstar's late...
The King of Fighters ALLSTAR, Netmarble's popular action RPG, has once again been updated with a plethora of new content. This includes battle cards, events and 21 new fighters, which increases the already sizeable roster even more. [Read more] | Read more »
Romancing SaGa Re;univerSe, the mobile s...
Square Enix latest mobile spin-off Romancing SaGa Re;univerSe is available now globally for both iOS and Android. It initially launched in Japan back in 2018 where it's proven to be incredibly popular, so now folks in the West can finally see what... | Read more »
Away: Journey to the Unexpected is a sto...
Away: Journey to the Unexpected looks really quite lovely. Stylish, cute, and clearly heavily inspired by Japanese animation, it's amongst the best-looking mobile games on the horizon. Developed by a two-person team, this story-driven rogue-lite... | Read more »

Price Scanner via MacPrices.net

July 4th Sale: Woot offers wide range of Macs...
Amazon-owned Woot is blowing out a wide range of Apple Macs and iPads for July 4th staring at $279 and ranging up to just over $1000. Models vary from older iPads and 11″ MacBook Airs to some newer... Read more
Apple Pro Display XDR with Nano-Texture Glass...
Abt Electronics has Apple’s new 32″ Pro Display XDR model with the nano-texture glass in stock and on sale today for up to $144 off MSRP. Shipping is free: – Pro Display XDR (nano-texture glass): $... Read more
New 2020 Mac mini on sale for up to $100 off...
Amazon has Apple’s new 2020 Mac minis on sale today for $40-$100 off MSRP with prices starting at $759. Shipping is free: – 2020 4-Core Mac mini: $759 $40 off MSRP – 2020 6-Core Mac mini: $998.99 $... Read more
July 4th Sale: $100 off every 2020 13″ MacBoo...
Apple resellers have new 2020 13″ MacBook Airs on sale for $100 off Apple’s MSRP as part of their July 4th sales. Starting at $899, these are the cheapest new 2020 MacBooks for sale anywhere: (1) B... Read more
This hidden deal on Apple’s site can save you...
Are you a local, state, or federal government employee? If so, Apple offers special government pricing on their products, including AirPods, for you as well as immediate family members. Here’s how... Read more
Apple Watch Series 3 models on sale for new l...
Amazon has Apple Watch Series 3 GPS models on sale for $30 off MSRP, starting at only $169. Their prices are the lowest available for these models from any Apple reseller. Choose Amazon as the seller... Read more
Deal Alert! Get these refurbished 2018 13″ Ma...
Apple has restocked and lowered prices on select Certified Refurbished 2018 13″ MacBook Airs, starting at only $679. Each MacBook features a new outer case, comes with a standard Apple one-year... Read more
July 4th Sale: 13″ 2.0GHz MacBook Pros for $2...
B&H Photo has new 2020 13″ 2.0GHz MacBook Pros on sale for $200 off Apple’s MSRP as part of their July 4th sale. Prices start at $1599. These are the same MacBook Pros sold by Apple in their... Read more
July 1 only: $100 off Apple iPhone 11, 11 Pro...
Boost Mobile is offering Apple iPhone 11, 11 Pro, and iPhone 11 Pro Max models for $100 off MSRP with service. Their discount reduces the cost of an iPhone 11/64GB to $599, iPhone 11 Pro to $899 for... Read more
Apple offers $50-$100 Education discount on i...
Purchase a new 12.9″ or 11″ iPad Pro at Apple using your Education discount, and Apple will take $50-$100 off their MSRP. All teachers, students, and staff of any educational institution with a .edu... Read more

Jobs Board

Operating Room Assistant, *Apple* Hill Surg...
Operating Room Assistant, Apple Hill Surgical Center - Full Time, Day Shift, Monday - Saturday availability required Tracking Code 62363 Job Description Operating Read more
Perioperative RN - ( *Apple* Hill Surgical C...
Perioperative RN - ( Apple Hill Surgical Center) Tracking Code 60593 Job Description Monday - Friday - Full Time Days Possible Saturdays General Summary: Under the Read more
Product Manager, *Apple* Commercial Sales -...
Product Manager, Apple Commercial Sales Austin, TX, US Requisition Number:77652 As an Apple Product Manager for the Commercial Sales team at Insight, you Read more
*Apple* Mac Product Engineer - Barclays (Uni...
Apple Mac EngineerWhippany, NJ Support the development and delivery of solutions, products, and capabilities into the Barclays environment working across technical Read more
Blue *Apple* Cafe Student Worker - Pennsylv...
…enhance your work experience. Student positions are available at the Blue Apple Cafe. Employee meal discount during working hours. Duties include food preparation, Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.