Beautiful Website In The Works

This E commerce store is taking our clients business from brick and mortar to online and worldwide. This site is built upon the robust Magento platform. Allowing for stabilizability, amazon like reviews and ratings features among many other features. In addition to being built on Magento this project also boasts custom WordPress Integration allowing for social media marketing as well as some SEO boosting benefits.

SmartPath Financial is a financial coaching company that helps you get out of debt, manage your finances, and move forward with your finances instead of backwards.

Our Involvement:

This beautiful site was a PSD to WordPress conversion. During this process we created the theme from scratch enhanced the site with custom jQuery animation and added to the Graphics and aesthetics. Check it out.

Solutions Realty Network is a property management company based out of Tyrone GA. Imperative Design is spearheading a complete redesign of their site and taking the rains for their SEO campaign. Stay tuned for the after picture.

Dartnell Academy is a really interesting company. They are a real estate company that arms you with all of the information needed to make a decision, without ever even setting foot on the property. In addition, you dont have to be a real estate pro to work with them. If you are a first time home buyer or even someone looking to become a more serious real estate investor, Dartnell offers a robust coaching program to train you to be your own real estate guide. They take the average Joe’s and make them Donald Trump’s.

My Involvement:

Imperative has an on going relationship with Dartnell where we are taking their website and helping to bring it to the next level. We are doing this by reworking their WordPress Templates , adding in custom jQuery, and integrating custom API’s to help them power their business.
Imperative Design is currently spearheading Dartnell Academy’s web presence and we are currently creating a new website from scratch, powered of course by WordPress.

European Hardwood Floors

European Hardwood Floors is one of Georgia’s premier flooring companies that offers a wide range of services. Whether you are looking for a refinishing for your current floor or new installation they do it all. They serve Atlanta, Gwinnett, Buford, Fulton, and all of the surrounding areas.

Duluth Diner

Check our this great restaurant with great food.

Beautiful WordPress site with custom plugins and custom JavaScript.
Site:Duluth Diner

Need an example?

• abort
• getAllResponseHeaders
• getResponseHeader
• Open
• Send

• onreadystatechange: contains the name of the event handler (function to call) when the value of readyState property changes.
• readyState: State of the request ( read only and status code )
• responseText: Body of the response. Returned as a string
• responseXML: Body of the response in XML format.
• status / Status (ie): HTTP Status code returned by a request
• statusText: response status text
  

Making the request object:

• method: Get, Post, PUT, HEAD, or PROPFIND
• URL: is the URL
• asyncFlag: whether or not the call is async. The default is true.
• username: s/e
  
• password: s/e



Handling The Data That Is Returned

---


Once the connection has been opened, a callback function is fired. This function is meant to fire when data begins to download or after data has been downloaded. The request object will call the callback function. This is done by assigning the callback function to the onreadystatechange property of the request object like so:

              XMLHttpRequestObject.onreadystatechange = myCallbackFunction;

This step can also be done using an anonymous function.

onreadystatechange has several numeric codes that serve as status indicators. Here they are:


• 0 – unitialized
• 1 – loading
• 2 – loaded
• 3 – interactive
• 4 – complete

The status property also has status codes. These are normal HTTP status codes and the values are as follows:


• 200 – ok
• 210 – created
• 204 – no content
• 205 – reset content
• 206 – partial content
• 400 – bad request
  
• 401 – unauthorized
• 403 – forbidden
• 404 – not found
• and on and on… http://www.w3.org/Protocol/HTTP/HTRESP.html

Inside of your callback function you can have an “if” statement that checks the status code. If the status code is 4, meaning the data download is complete, and the status property is 200, meaning that it went well, then we can proceed with the data download. This is usually done by firing another method, the send method.



Conclusion:

---


You have seen the basic steps that it takes to make an AJAX connection and talk to the server. For a quick summary here are the necessary steps.


1. Create the XMLHttpRequest Object.
2. Use the open method to configure it.
3. Call an anonymous function to handle the data download by connecting to onreadystatechange
4. Use the send method to execute the request
   

]]> http://imperativedesign.net/javascript/ajax-for-beginners/feed/ 0 http://imperativedesign.net/tutorials/enumerations_and_structures-2/ http://imperativedesign.net/tutorials/enumerations_and_structures-2/#comments Thu, 02 Dec 2010 17:58:50 +0000 peb7268 http://imperativedesign.net/tutorials/enumerations_and_structures-2 Continue reading →]]> So you have seen basic data types, arrays, and even objects! You are progressing rapidly, however there are a few other data types that are important to at least be able to recognize. The two items we will discuss today are called Enumerations and Structures.

An enumeration, enum for short, is a “list of named integer constants”. What does that mean? Suppose you have a list of students and you are wanting to make a seating chart. ( This is for you Mr. Carter ) With an enumeration you can make a list of a group of students. Each name represents an integer starting at 0. This is similar to the way in which arrays are indexed. The difference is that you can use an enum element anywhere you can use an integer.




Example Time:

---




Prototype:




enum type-name { enumeration list } variable-list; enum seatingChart {Jonathan, Susan, Tommy, James, Lisa} char1, chart2;

Lets take a look at what is going on here!

An enumeration called seating chart is declared with the keyword enum. Each of its elements represents an integer: (Johnathan being 0, Susan being 1, and so forth..). Two charts ( creatively labeled chart1 and chart2 ) are declared of type seatingChart. The elements that make up the enumeration are known as the enumeration list. Once the enumeration is defined you can create another instance of it using its name: seatingChart chart3; This creates another seatingChart enum. Kind of like using a class to create an object. Enum members can be used as keys for an array or anywhere else integers can be used.

To see this more clearly examine the following example:

enum seatingChart { Paul, Mary, Tom, Jody }; sum = Mary + Tom;
cout << “The value of Mary + Tom is: “<<sum; //

This will return the following:

The value of Mary + Tom is: 3 // Why? Because the enum list starts its index at 0, then Mary is 1 and Tom is 2.





Enough about Enums already…tell me about a struct?!

---




Struct stands for Structure. It is a way of grouping related data together in neat packages. This in turn allows you to refer to a collection of variables as one name. It has features that are both object oriented as well as non object oriented. Structures are very similar to classes in nature and in behavior and only differ slightly in implementation, specifically in the way they hide their data. In today’s article we will cover the non-oop features.




Items in a structure are called members ( also known as fields or elements ) What is it useful for? Since you can only return one thing from a function it would be cool to be able to return a struct right? Think of how useful it would be to have a function that initialized all of your stuff in a program that worked with students’ grades. You could prompt the user to input the grades, pass them to a calcGrade function and it would work its magic, repackage them into a struct, and return the struct to the rest of the program. Cool huh?


]]> http://imperativedesign.net/tutorials/enumerations_and_structures-2/feed/ 0 http://imperativedesign.net/tutorials/c_plus_plus_and_oop/ http://imperativedesign.net/tutorials/c_plus_plus_and_oop/#comments Thu, 02 Dec 2010 03:48:24 +0000 peb7268 http://imperativedesign.net/tutorials/c_plus_plus_and_oop Continue reading →]]> Ok, so you’ve heard the terms, listened to the heated nerd debates over it, and even scratched your head a few times wondering what object oriented programing is and why you should choose to use it over what you already do. This article will serve as one of many guides for beginners looking to hone their object oriented skills as it relates to C++. As a side note, this also ties closely to other languages such as Objective-C, a programing language used for iPhone development, Java, and even PHP for web development. So, without further ado, lets discuss the different components of OOP.







Object Oriented Programing is a way of grouping your code into reusable blueprints. These blueprints contain functions, variables, and various other tools. The manipulation of these tools is what makes your programs more powerful, easier to update, more secure, easier to work with, and best of all REUSABLE.




This concept of re-usability is one of the main reasons why people love OOP. Think about the following scenario. Suppose an architect is designing a subdivision with a total of one hundred houses. Think of the time it would take and the additional money he would need to charge if he had to design a completely new blueprint for each house individually. That would take forever! Why should he have to redesign a whole blueprint because one house has an extra bathroom or a slightly different floor plan?




This same concept applies to programing. Think of the real world applications you will have to develop if you go into programming. These can consist of an accounting application, or a banking application, perhaps a commerce application, or payroll software. What do all of these have in common? They each have employees, or products, or hours to keep track of. Instead of writing a new program each time, wouldn’t it be nice if we had a reusable blueprint for every payroll application, or for each program that uses products or employees? This is what classes are. They are reusable code blueprints that make our lives easier by saving us time and work.




???

---




How do they differ from just saving my programs and reusing the entire program? Where your programs are specific in their function and nature, classes are meant to be general in nature. Instead of having to painstakingly hack away at a program that is meant to do one thing and make it do something else, you can implement a class and then make it more specific to fit your exact needs. You have been using prewritten classes all along in your programing. Each time you include iostream and use cout or when you use fstream to create a new file object you are working with classes. Another benefit of these is they have been written well once and are continually being improved upon. Thus they have been thoroughly debugged and tested.




Enough theory? Lets skip to the action!

---




When making a class you must define it just as you would when you declare a function. You specify what functions (known as methods in OOP speak ) and what properties ( aka variables ) will be in each object. Then you instantiate (create an instance of ) the object. Once the object has been instantiated it will contain all of the elements that the class has and can be worked with uniformly. Hence, in terms of the previously used example, each house in the subdivision has a roof, a kitchen, a bathroom, and floors.


Here’s how you create a class:

#include <iostream>
#include <string>
using namespace std;

class Banner
{
public: string favoriteProgram;
public: static int numberOfObjects;   
};



This code has just created a class called Banner. It will be used to display some information. It has two properties (variables): favorite program and number of objects. If you are asking where is main ( ) at then that is a good observation. Classes aren’t meant to be called directly by main. They are meant to be defined (typically in includes files) and then instantiated in your program and worked with. We will get to a full example shortly. As for the public keyword, OOP provides a way to keep your data safe. Sometimes when working with loops, functions, or just complicated code, when you get a big program going your variables might get accidentally changed or declared in the wrong places. OOP fixes this with something called encapsulation and data hiding. We will revisit this subject a little later.


Here is a bit more complex code:

#include <iostream>
#include <string>
using namespace std;

class Banner
{
public: string favoriteProgram;
public: static int numberOfObjects;
};

//constructor
public: Banner()
{
numberOfObjects++;
favoriteProgram = “C++”;
}


public: void Display()
{
cout << “I love ” << favoriteProgram << endl;

}

public: void howMany(){
cout << “nThe number of current Banner objects is: “<< numberOfObjects <<endl;
}



This whole section of code is what my definition of the class looks like. It has 3 methods in total (one of which is a constructor) and two properties (variables). A constructor is basically a function that is called whenever you create an object. Any time I create an object of type banner it looks for a function with the same name, Banner. Then it does whatever the constructor tells it to do. Typically, this setup task involves setting default values and initializing certain things. It’s like using a mainline setup in procedural C++. All of this setup code is usually just put in an includes file with a .cpp or .h extension. Then, instead of typing a whole C++ setup each time you start a fresh project, you can just grab one file off your flash drive and boom.. you have a program that’s setup.




Implementation

---




Well its nice to see how it is setup but how does it get implemented into the main and ran? Now that you have seen the way to set it up, here is the method for working with it:

//When including a .h file in use the quotation marks and no angle brackets
#include “setup.h”

//scope resolution operator allocates space for the static variable
int Banner::numberOfObjects;

//Set a global variable to test in the program and define a function header to work with it
int globalNum=5;
int SetGlobalNum();

int main () {

/*
char name[256];

cout << “Hello, World!nn”;
Banner cpp;
cpp.favoriteProgram = “C++”;
cpp.Display();

//create a second instance of the banner class
Banner java;
java.favoriteProgram = “Java”;
java.Display();
java.howMany();
java.howMany();

//cout << “nnWhat is your full name name?n”;
//cin >>name;
//cout << “You put: “<<name <<endl;
cout << “nnNow using cin.getline()n”;
cout << “Enter your full name again: “;
cin.getline(name,256);
cout << “You entered: ” <<name;
*/

//Set and display the global Number
cout << “nWhen declared globalNum starts at: ” <<globalNum;
globalNum = 7;
cout << “nIn Main globalNum now equals: ” <<globalNum<<”nn”;
SetGlobalNum();
cout << “Back in Main globalNum now equals: ” <<globalNum;
return 0;
}

//Function Header
int SetGlobalNum(){
int tempNum;
cout << “nIn the Function:n”;
cout << “Enter a new number for globalNum: “;
cin >> tempNum;
globalNum = tempNum;
return globalNum;




What just happened?

---




We included our class definition and setup that we made in the code above. Separating things makes maintenance, troubleshooting, and expansion much easier in the long run, not to mention the short run as well! We allocated space in our program for a static variable. Don’t sweat this yet. We will cover it more in depth later. It just means that when functions are called that use this variable, when the function ends, the variable keeps its value so we can reuse it later. We created a character array, printed some stuff to the console, and did some basic setup.




The fun stuff happens here:

Banner cpp;                                   //This creates an instance of the Banner class called cpp
cpp.favoriteProgram = “C++”;        //This then sets the property favoriteProgram to C++
cpp.Display();                               //This then calls the method Display ( ) from the cpp object.





Any time you access a method or property of an object in C++ you use dot syntax. The line cpp.Display serves to distinguish Display method of cpp from the Display method of, say, a Java object or Perl object. That means you can have many different objects that behave the same way, are worked with in the same way, but are independent of each other. Each has its own data and behaviors. This is known as the objects state.




Think of how we would have done this before with procedural programming. What would you have done if you would have had to create a program to keep track of students and their grades? Made a bunch of variables and then put them in modules and then passed a bunch of stuff around? Now, using OOP, you can just make a student class. Then make the following students, John, James, Paul, Cindy, and Susan, objects and have them do their own work, keep up with their own grades, and calculate their own grades.





Where To Next?

---




Hopefully you have just become a little more at ease with OOP and how C++ implements it. You may have to read this once or twice to get a good grasp on it. I know it can be a bit overwhelming at first. If you have any questions as always feel free to comment or email me. In the next few tutorials we are going to be talking more about how objects and classes make things easier.





Next up will be Inheritance. This will go over the process where you take a class, for example students, and then create a subclass which is more specific and specialized. You are then able to utilize all the variables and functions (methods and properties) previously mentioned.



]]> http://imperativedesign.net/tutorials/c_plus_plus_and_oop/feed/ 0 http://imperativedesign.net/tutorials/beginning-file-io-with-c/ http://imperativedesign.net/tutorials/beginning-file-io-with-c/#comments Thu, 02 Dec 2010 01:28:25 +0000 peb7268 http://imperativedesign.net/tutorials/c_plus_plus_and_file_io Continue reading →]]> File I/O has been a bit of a daunting subject for a lot of beginning programmers for a long time now. When I first began programming in PHP I know it seemed a bit foreign to me. You, however, won’t have that problem. By the end of this tutorial you will have gotten a basic understanding of what file IO is in C++ and how to work with it on a lower level. Lets jump in!!



In order to use file IO in C++ you must include one of several library header files and then instantiate objects from those files. For the sake of brevity and simplicity we will delve only into one of these header files: The fstream.




There are two basic things you can do with a file: read or write. Depending on which option you want to do you must include a particular library and then instantiate an object from that library. You can cut all that hubub out though by simply using fstream as a catchall class. It can read and write. Think of it as a master class. So here is the basic play by play of what you do to work with a file.



• Include fstream
• Instantiate a object of the class
• Test to see if the object was found if not provide an error message so you don’t loose your sanity and pull your hair out.
• Read or Write ( you can append flags as well to modify the way reading or writing occur)




Example Time!!

---


#include
#include
#include
using namespace std;

//Instantiated an object from my ofstream class
ofstream fileOut;

int main () {


//File Ouput – This method will overwrite what is in the existing file.
/* fstream fileOut(“/Users/peb7268/Desktop/demo.txt”);
if (!fileOut.fail()) {
cout << “nFile found. About to commence writing.n”;
fileOut <<”Here is some output again!”;
} else {
cout <<”nError, the file not found.n”;
}
*/


/*– Setting some flags ——————————————————————-*/
//File Ouput – This method will overwrite what is in the existing file.
//By specifying a formatter as a second argument you can manipulate what happens during the file conversation
ofstream fileOut(“/Users/peb7268/Desktop/demo.txt”,ios::app);
if (!fileOut.fail()) {
cout << “nFile found. About to commence writing.n”;
fileOut <<”nThis is a linen”;
cout << “nI came, I saw, I wrote!n”;
} else {
cout <<”nError, the file not found.n”;
}


return 0;
}



Moving on…

---




Reading a line of a file is not much more complicated, but reading several lines can be a bit tricky if you are a novice. To read multiple lines from a file you just use a loop and test for while not the end of the file. Use a string object to store multiple strings or a int or float for numbers.




Here are a few examples:

To store a line from a file (and not just one word till it hits whitespace) use your trusted friend getline( ) again. The only difference is that instead of taking the format cin.getline (aVar, maxVal) it takes a new form of getline (inFile,tempVar). To get a better idea of how this works look at the code below:

#include
#include
#include
using namespace std;



int main () {

fstream inFile;
inFile.open(“/Users/peb7268/Desktop/demo.txt”);
//char tempVar[256];
string tempVar;

if (!inFile.fail()) {
cout << “nReading File…n”;
} else {
cout<<”Error reading the file.”;
}

while (inFile) {
cout << “n”<
getline(inFile,tempVar);
}
if(inFile.eof()) { inFile.close(); }


return 0;
}



Moving on.. File IO & Arrays:

---




Sometimes you may want to read data from a file and store it in an array so you can work with it again later. The steps for this are not super complicated. Here is the general approach you would take:



• Create a constant for your array size.
• Declare a new array with the size constant
• Open the file
• Use a for loop and a counter to pull in the numbers to the array.

Here is how these steps look in actual code:

const int ARRAY_SIZE = 10;
int numbers[ARRAY_SIZE];
int count;

ifstream inputFile;

inputFile.open(“demo.txt”)

//Reads the elements in the numbers array into the inputFile object
for(count=0; count < ARRAY_SIZE; count++)
inputFile >> numbers[count];

inputFile.close();

//Display the numbers
cout <<”The numbers are: “;
for (count=0; count < ARRAY_SIZE; count++)
cout << numbers[count] << “n”;
cout << endl;

Writing to a file works pretty much the same way but you just use a different stream operator.



Recap

---




In case you don’t know what the fail() method does, it returns a boolean value indicating whether or not the function was successful. In the previous lines of code you have seen how to work with files and how to set flags when writing. You have also learned how to pull in more than one line from a file.

If some of this seems a bit foreign with all the talk of objects, classes, and functions with the same name but different ways of working, then stay tuned. The next post is on C++ and how it puts its own twist on OOP. If you have any questions, feel free to leave them in the comments section!



]]> http://imperativedesign.net/tutorials/beginning-file-io-with-c/feed/ 0