Keyword Attribution Management System

keyword attribution management system

Finding the Right Keyword Attribution Management System

Finding the Right Keyword Attribution Management System is an important tool in Ecommerce. Web user behavior is rarely as simple as a single search leading to a conversion. Rather, online consumers tend to search in patterns that gradually become more specific as they understand more about the products and services they are seeking.

An effective keyword attribution management system will properly identify the search patterns employed by users, providing the data necessary to optimally position your website in each stage of the search process.

Three searches is all you need

First Search (Introducer): “Pet Supplies”

Second Search (Influencer Keyword): “Cats”

Third Search (Closer Keyword): “XYZ Cat Food”

A good keyword attribution management system is a 3-step process

to this keyword attribution management system, three steps is all you need to retrieve actionable data from your web analytics program. The initial search fills the role of introducer. It is the most general of the three searches, and has its pros and cons as to if/how much time, energy and money should be spent for this broadest phase of the search cycle. At this stage the product and/or service your website offers is still thought of in general terms, such as “real estate” or “pet supplies.” If you’re one of the “big boys” and can afford to pay ridiculous amounts – or amounts that would seem ridiculous to a smaller competitor – of money for pay-per-click placement on these broad search terms, then go for it.

Follow that traffic after it lands on your site

Otherwise, you’ll want to follow the traffic that enters your site via these general search words and phrases on to further stages before you take action. Let’s say our seeker after cat food has made his way from his entry search term – “pet supplies” – to “cats.” Let’s say, moreover, that the referring link was found in an article on the health advantages of pet companionship for seniors. O.K! I believe we’ve got some actionable data at this point! But what if these people who may be seniors, or someone who is thinking of getting a pet for elderly parents, goes on to click on “cat food.” Do we have an actionable trail of data at this point? Can we give the marketing a green light and tell them to go ahead and whip up a well-honed and effective marketing campaign based on these click paths? We know a few things about our site visitors at this point. First of all, there is a good chance they want to procure pet supplies now or in future. In other words, there is a good chance that they are buyers and not just early-stage investigators, We also know that they are senior citizens who are going to buy cat food for themselves or family members who are thinking of getting a cat for Mom and Dad.

Let’s say we have a cat and that cat needs food. A reasonably intelligent starting point would be the search term “pet supplies.” While we’re at it, let’s call this first search the

Most general search term lands them on your site

Landing Strip search phase, because with this particular click behind us we’ve just landed on somebody’s web site.

A good  keyword attribution management system is both broad  and specific

#1: (Landing Strip): “Pet Supplies.”

This term is broad enough and specific enough at the same time to give us a reasonable degree of assurance that we are on the right track. There is a good chance that the search results will include a usable list of businesses that carry supplies for pets. At this point we may find ourselves at a fork in the road,

With our fork-choices consisting of “Now Click on Cats” or “Now Click on Food.” On the one hand, making a big deal out of this predicament may seem trivial and pointless. Assuming that the pet supply businesses given in the first few search results will be smart enough to have a web development plan that puts the emphasis on an easily-navigated and logical site structure – as well as on the optimization of these two basic sub-categories (cats and food), Let’s say this choice is pretty much a choice between “good” and “better,” and that clicking on either term will get us to our site/page destination quickly enough! Just for argument’s sake, let’s choose “cats” as the second level search term.

As search continues make search terms more specific

Say we choose the term we think will work better at this stage of the game – “cats.”

Things to remember here:

  • Don’t jump the gun by making unwarranted inferences from the data. We are playing detective here, so just follow the evidence without falling into the common trap of wishful thinking. The beauty of web analytics tools is that they allow us to proceed empirically by breaking the data down into bite-sized chunks.
  • Simple two-or three-segment reports can work wonders. Google Analytics evangelist Avinash Kaushik comes back to this point time and time again, and it is a point well taken by those in the know re everything analytics-related. Action is the desired result of data-collection, not further analysis. Knowing who your referrers are, where they went once on your site and where they exited – simple three segment analysis – can yield actionable results.
  • ABT…always be testing (or always be tweaking the results of these reports). Whether you see web analytics as a daily chore on a par with making sure that your office bathroom is stocked with essentials or, on the other hand, something much loftier, it is the ant who wins this race – not the grasshopper. It is an ongoing and permanent task for your business – web analytics – and dependent on the persistent efforts of people who understand the need to analyze, analyze and analyze – and make req1uired changes – on a regular basis. Attention to facts/figures and the ability to perceive meaningful patterns for same are what you want in your analytics team, not the desire to score a great big coup for your business by making a once-and-for-all breakthrough in data analysis that will solve your company’s financial problems in one fell swoop and forever.

Second Search (Influencer Keyword): “Cats”

Third Search (Closer Keyword): “XYZ Cat Food”

…to be continued

 

 

Please like & share:

Keyword and Multi-Channel Attribution

keyword research

 Keyword and Multi-Channel Attribution…read on to learn how to make keyword
and multi-channel attribution your path to a successful website. Continue reading

Please like & share:

Model and Measurement Musts for Google Analytics

Kuashik and web analytics

When it comes to all things web-analytical there is nobody like Avinash Kaushik. Widely known as an evangelist for Google Analytics (and web analytics in general), his books are considered by many to be the leading authority on web analytics. His tutorials on YouTube and at his web site – Occamsrazor.com – are followed and enjoyed by people all over the world. (Just check out the number of languages in which comments are posted on these sites). Continue reading for some helpful insights  into Model and Measurement Musts for Google Analytics.

His book “Web Analytics 2.0”  has so much information on so many levels that anyone who is serious about learning Google Analytics or any other web analytics platform  would do well to have his or her own copy of this classic.

Kaushik is no respecter of persons, when it comes to evaluating the status quo of commercial web analytics. His constant reminder that big is not necessarily better drives home a very important point for web analytics users:fancy analytics reports are worthless unless action is taken to do something with the data they contain!

Do something with your data

His advice to newbies is don’t be afraid to act on the little data you may have. Google Analytics is too rich and complicated a tool to wait until you have mastered it before you go ahead and apply report data to your website.

Like all those who truly know what they’re talking about, Avinash Kaushik seeks to simplify, clarify, and take joy in sharing what he knows with those who are less knowlegable.

The following tutorial on digital metrics and modeling can also be read in its entirety at http://www.kaushik.net/avinash/digital-marketing-and-measurement-model/

Digital Marketing and Measurement Model

There is one difference between winners and losers when it comes to web analytics. Winners, well before they think data or tool, have a well structured Digital Marketing & Measurement Model. Losers don’t.

This article guides you in understanding the value of the Digital Marketing & Measurement Model (notice the repeated emphasis on Marketing, not just Measurement), and how to create one for yourself. At the end you’ll also find some additional examples to inspire you.

Let’s go…

The root cause of failure in most digital marketing campaigns is not the lack of creativity in the banner ad or TV spot or the sexiness of the website. It is not even (often) the people involved. It is quite simply the lack of structured thinking about what the real purpose of the campaign is and a lack of an objective set of measures with which to identify success or failure.

I’ve developed the Digital Marketing & Measurement Model as a simple, structured, five step process to infuse this much needed thinking. Here is what each step in the process helps accomplish:

Step one

    • is to force us to identify the business objectives upfront and set the broadest parameters for the work we are doing. Sr. Executives play a key role in this step.

Step two is to identify crisp goals for each business objective. Executives lead the discussion, you’ll play a contributing role.

Step three is to write down the key performance indicators. You’ll lead the work in this step, in partnership with a “data person” if you have one.

Step four is to set the parameters for success upfront by identifying targets for each KPI. Organization leaders play a key role here, with input from Marketing and Finance.

Step five, finally, is to identify the segments of people / behavior / outcomes that we’ll analyze to understand why we succeed or failed.

Simple, right? It is harder than you might think, “soft” work always is. Before we go into each step in detail I want to share something extremely critical. The scope/breadth the model has to cover.

A complete, and competent, Digital Marketing & Measurement Model will focus on three key areas of your marketing, and in each answer the cluster of questions provided:

1. Acquisition.

      • How are you anticipating acquiring traffic for your website / YT video / whatever else you are creating? Did you cover all three components of successful acquisition: Earned, Owned, Paid media? How would you prioritize each? Where are you spending most of your efforts?

2. Behavior.

      • What is the behavior you are expecting when people arrive? What pages should they see? What videos should they watch? Should they visit repeatedly? Are there certain actions they should take? What is unique about your effort that ties to an optimal experience for a customer?

3. Outcomes.

      • What outcomes signify value delivered to the business bottom-line? A download? A phone call to your call center? A qualified online lead? Signing up for email promotions? People buying your product / services ? A 95% task completion rate? A 10 point lift in brand perception?

Simply put: Why are we undertaking this digital initiative?

My sincerest hope is that these questions will seed your discussions as you go through the five steps below. If your Digital Marketing & Measurement Model does not cover all three areas of your digital effort, then it is not complete. Please consider revisiting it. Don’t accept a mediocre model.

With that macro thought out of the way, let’s get going and look at a real example of the five step process to solidify this concept.

The business we are doing this for is a real estate company. I’ve picked a tough one because the main outcome is offline success. If they can create a good model then your job is much much easier!

Step 1: Identify the Business Objectives.

Ask this question: Why does your website/campaign exist? (Think of acquisition, behavior and outcomes.)

This is a difficult question to answer because it requires more thinking that you might anticipate. If you do it right at the end of step one you’ll have something that looks like this:

digital marketing measurement model step one

Identifying the business objectives mandates a discussion, multiple discussions, with the senior-most leaders in your company and working with them / sweet-talking their egos and hearts with gentle encouragement, to identify why the site / campaign / digital marketing invitiative exists.

Based on those discussions, in our case, we’ve identified three objectives: Create awareness, generate leads for the builders and highlight community events.

Here’s a great test. Your objectives should be DUMB:

D

      • oable.

U

      • nderstandable.

M

      • anageable.

B

      • eneficial.

If they are too out there, you’ll never get anywhere. If they are too vague, nothing will get done. If they are too lame, they’ll inspire no one. Go for real world, clear, executable and those that deliver value to the company (short term and long).

Are your objectives dumb?

Pro Tip: One way to ensure success is to forget that you are creating a set of videos or that you are building a site to host downloads of pdfs or that you are trying to mimic a campaign from Europe. Really, really, really think hard about why you are doing what you are doing. Get the answer from your executive/client.

Step 2: Identify Goals for each Objective.

Drilling down to identify website/campaign Goals requires critical thinking from both the Management, Marketers, and the Analysts – with Management in the leadership role.

My definition: Goals are specific strategies you’ll leverage to accomplish the business objectives.

After going through some of the acquisition, behavior questions with stakeholders, here’s our model:

digital marketing measurement model step two

Clean. Has a clear direct line between Goal and each objective. Provides immense clarity.

To deliver on “Create Awareness,” in this case, the site needs to support all the offline efforts along with having a relevant online traffic acquisition strategy.

“Generating Leads” comprises the twin goals of providing all kinds of information that will help potential home buyers to make their decision and to collect e-newsletter registrations as well as e-requests for an onsite tour of the model home by the builder.

Finally, “Highlight Events” is for prospective home buyers (visitors to our site). By making them happy with delightful events, at the construction site hopefully in model homes for sale, they can be converted into Net Promoters (to others) and Buyers (themselves).

These goals provide clarity, but they also contain large chunks of specific marching orders for what the Marketers and Analysts need to get done.

Pro Tip: This is super key: Macro + Micro Conversions! If the goals identified don’t cover all the jobs the site/campaign is doing then you might need to revisit your work.

Step 3: Identify the Key Performance Indicators.

Finally we get to deal with data!! I know you’ve been dying to get here. You’ll be the ideas leader here.

My definition: A key performance indicator (KPI) is a metric that helps you understand how you are doing against your objectives.

For each goal, sweat, and find the most hyper relevant KPI. This is what it will look like:

digital marketing measurement model step three

Please like & share:

Collections & Sorting

Stamp Collector

Collections is a class with only static methods, devoted to operations on objects with collecting characteristics, List, Map, and Set. It can:

  • copy collections
  • put all contents of a collection into another
  • sort collections
  • reverse the order of collections
  • randomly shuffle a collection
  • find frequency of elements
  • and more, but perhaps the most often used is sort.

Sorting our objects can be done by three standard methods:

  • equals()
  • compareTo()
  • compare()

The latter two are the ways that Collections uses to sort data.

 

equals()

This is a method included with class Object, so therefore it is included with every type of object.

It returns a boolean value (true or false) saying whether this object is “equal” with another.

It can and is expected to be overridden to compare objects by your customized way.

Example (try it):

class Cat
{
   int age;
   Cat(int age)
   {
      this.age = age;
   }

   public boolean equals(Cat other)
   {
      return this.age == other.age;
   }
}

 

compareTo()

This method comes from the java.lang.Comparable<T> interface:

int compareTo(T object)

is implemented to compare this object with another to give a negative value for this object being less than, 0 for equals, or positive value for greater than the other.

This is the more convenient compare method, but must be implemented in every class you want to compare.

Example (try it):

class Cat implements Comparable<Cat>
{
   int age;
   Cat(int age)
   {
      this.age = age;
   }
 
   public int compareTo(Cat other)
   {
      if (this.age < other.age)
       return -1;
      else if (this.age == other.age)
       return 0;
      else
       return 1;
   }
}

Note that a simpler way to write the method above is:

return this.age - other.age; //- value for <, 0 for ==, + value for >

 

compare()

This method comes from the java.util.Comparator<T> interface:

int compare(T obj1, T obj2)

is implemented in a separate class that compares another class’s objects to give a negative value for the first object being less than, 0 for equals, or positive value for greater than the second object.

It is needed when you cannot make a class implement compareTo() because it is not modifiable. It is also used when you want different ways to compare objects, not just one (such as by name or age)..

Example (try it):

class Cat
{
   int age;
   Cat(int age)
   {
      this.age = age;
   }
}

class CatComparatorByAge implements Comparator<Cat>
{
   public int compare(Cat first, Cat second)
   {
      if (first.age < second.age)
         return -1;
      else if (first.age == second.age)
         return 0;
      else
         return 1;
   }
}
Please like & share:

Design Patterns

Design patterns are common, effective solutions to software design problems.

 

Iterator Pattern

An object traverses and accesses elements of a collection, rather than the programmer directly manipulating the collection.

Purpose is to simplify traversal of a collection and hide the details of its inner workings.

Example:

LinkedList list = new LinkedList();
//...add elements...
ListIterator iterator = list.listIterator();
while (iterator.hasNext())
{
     Object element = iterator.next();
     //do something with element
}

This is better than a version of LinkedList that would allow the user to access its nodes directly, like so:

Node node = list.head;
while(node != null)
{
     //do something with node.element
     node = node.next;
}

This is because this complicates things (in working with links) and thus is prone to errors.

In Java, list iterators can be imagined like the cursor in a text processor that moves along characters, the characters being like elements of a list.

Adding element adds it and advances the iterator position by one.

Adding element adds it and advances iterator position by one.

 

Singleton Pattern

A public one-of-a-kind object exists as a static variable.

Purpose is to ensure only one object of a type is publicly available.

Example:

class System
{
     //single God instance.
     static God god = new God(); 
     private class God
     {
          void create()
          {
          }
     }
}

 

Observer Pattern

Henri_Matisse,_1916-17,_Le_Peintre_dans_son_atelier_(The_Painter_and_His_Model),_oil_on_canvas,_146.5_x_97_cm,_Musée_National_d'Art_Moderne,_Centre_Georges_Pompidou,_Paris

An object notifies another object (the “observer”) whenever a change to a data has occurred.

Purpose for this pattern is encapsulation of data and distribution of responsibility.

Example:

//make button.
final JButton button = new JButton();
 
//make observer for mouse events.
MouseListener listener = new MouseAdapter()
{
     public void mouseClicked(MouseEvent e)
     {
          button.setText("clicked");
     }
};
 
//make it observe the button.
button.addMouseListener(listener);

Model-View-Controller (MVC) is an architecture that uses this pattern. Example: visualize a posing artist’s model (Model), a painter of the model (View), and a director of the model (Controller). The director controls the model’s state. Whenever it does, the model notifies the painter to update his representation of the model visible to the user.

Example:

// Model.
class Model
 {
     String state;
     Painter painter; //representer of model
 
     //notify painter when state changed.
     void notify()
     {
          painter.repaint(this);
     }
}
 
// View.
class Painter
{
     void repaint(Model model)
     {
          //update representation of model.
     }
}
 
// Controller.
class Director
{
     Model model;
     Director(Model model)
     {
          this.model = model;
     }

     void setModelState(String newState)
     {
          model.state = newState;
          model.notify();
     }
}

//The tester.
class Tester
{
     public static void main(String[] args)
     {
           Model model = new Model();
           model.painter = new Painter();
           Director director = new Director(model);
           director.setModelState("Sitting");
     }
}

Another way to think of Model-View-Controller, is Data-Output-Input. the input changes the data (as an interface to it), while the output represents the data to the user in whatever state it currently is in.

 

Adapter Pattern

A class (the “adapter”) implements an interface by blank methods to save its users from implementing every method when some are unneeded.

Purpose is nothing more than saving code.

Example:

//make button.
final JButton button = new JButton();
 
//make adapter implementing one method of an interface.
MouseListener listener = new MouseAdapter()
{
     public void mouseClicked(ActionEvent event)
     {
          button.setText("Clicked");
     }
};
button.addMouseListener(listener);

This is the same as, but shorter than, this:

//make button.
final JButton button = new JButton();

//make adapter implementing one method of an interface.
MouseListener listener = new MouseListener()
{
     public void mouseClicked(MouseEvent e)
     {
            button.setText("Clicked");
     }
     
 
     //implement unneeded methods as blank.
     public void mouseMoved(ActionEvent e)
     {  
     }
     public void mouseEntered(MouseEvent e)
     {
     }
 
     public void mouseExited(MouseEvent e)
     {
     }
 
     public void mousePressed(MouseEvent e)
     {
     }
 
     public void mouseReleased(MouseEvent e)
     {
     }
};
button.addMouseListener(listener);

 

Composite Pattern

composite

A class acts a container for its siblings and using this container simply uses all its contained objects, as a proxy.

Example:

abstract class Item
{
     abstract void use();
}
class Toy extends Item
{
     void use()
     {
          System.out.print("Beep!");
     }
}

class Perfume extends Item
{
     void use()
     {
          amount -= 1;
     }
 
     int amount = 10;
}

//Compositing class.
class Bundle extends Item
{
     # held items.
     List items = new ArrayList();
 
     # this simply calls use() of each held item.
     void use()
     {
          for (Item item: items)
              item.use()
     }
}

 

Decorator Pattern

rosiejetsons

A class acts as a container and proxy for a sibling, but also defines new features to enhance it.

This sounds like the Composite pattern, but Composite intends to collect, while Decorator intends to enhance.

Example:

//Class to be decorated.
class Robot
{
     void run()
     {
           ...
     }
}

//Decorating class.
class JetBot extends Robot
{
     //robot to enhance.
     Robot robot;
     JetBot(Robot robot)
     {
          this.robot = robot;
     }

     //enhancing features.      
     int fuel = 100;

     ...
}

 

Command Pattern

An action, in the form of an algorithm, is contained in an object to remember and use the algorithm later.

Example:

abstract class Job
{
     abstract void do();
}
class CleanJob
{
     void do()
     {
          //...
     }
}
class PrintJob
{   
     void do()
     {
          //...
     }
}

 

Strategy Pattern

Different algorithms that fulfill the same goal differently are saved.

Purpose is to save actions for use in different scenarios.

Similar to Command, but Strategy algorithms are intended for one goal, while Command algorithms are for different goals.

Example:

//strategy to sort Accounts.
class AccountComparatorByName implements Comparator<Account>
{
     public int compare(Account first, Account second)
     {
          return first.name.compareTo(second.name);
     }
}
 
//another strategy.
class AccountComparatorByID implements Comparator<Account>
{
     public int compare(Account first, Account second)
     {
          return first.id – second.id;
     }
}
 
//test: make list.
List list = new List();
list.add(new Account(8152, "David"));
list.add(new Account(1372, "Shawn"));
list.add(new Account(3283, "Ruth"));
 
//try sorting strategies.
Collections.sort(list, new AccountComparatorByName());
Collections.sort(list, new AccountComparatorByID());

 

Template Method Pattern

An abstract class contains one concrete method (the “template”) that calls several abstract methods, which are defined by concrete classes.

Example:

abstract class Game
{
     //Template method.
     void play(int players)
     {
          initialize();
          while (!isEnd())
               turn();
     }

     //Abstract methods.
     abstract void initialize();
     abstract void turn();
     abstract boolean isEnd();
}

class Chess extends Game
{
     void initialize()
     {
          //...
     }
     
     void turn()
     {
          //...
     }

     boolean isEnd()
     {
          //...
     }
}

class Poker extends Game
{
     void initialize()
     {
          //...
     }
     
     void turn()
     {

          //...
     }

     boolean isEnd()
     {
          //...
     }
}

 

Factory Method Pattern

A method implements an abstract method for only creating and returning objects.

Example:

abstract class AsexualOrganism
{
     abstract Object reproduce();
}
 
class Virus extends AsexualOrganism
{
     //factory method.
     Object reproduce()
     {
          return new Virus();
     }
}

Example:

//make list.
List list = new LinkedList();
 
//create iterator by the factory method iterator().
Iterator iterator = list.iterator();
 
//iterator() implements List’s method iterator().

 

Abstract Factory Pattern

An abstract class with factory methods has several subclasses in their own object creation theme.

Example: “LookAndFeel” classes for graphical applications

 

Chain Of Responsibility Pattern

Belt-conveyor-handling

Several handlers handle a request in sequence, like workers over a conveyor belt.

Example:

//make button.
final JButton button = new JButton();
 
//make two ActionListeners handling the same event.

ActionListener one = new ActionListener() 
{
     public void actionPerformed(ActionEvent e)      
     {
           System.out.println("Clicked!");
      } 
};

ActionListener two = new ActionListener() 
{
     public void actionPerformed(ActionEvent e)      
     {
          button.setEnabled(false);
      } 
};

button.addActionListener(one);
button.addActionListener(two);

 

Memento Pattern

An object’s old state is saved (like a “snapshot”) to later return to it.

Coupled with the Command Pattern, it is a useful pattern to create undo functionality by.

Example are found in How to Implement Undo/Redo.

 

Proxy Pattern

An object acts an interface (actor on behalf) to another object, being used exactly like that other.

Examples can be found in Adapter, Composite, and Decorator sections above.

Please like & share:

Software Process

The software process is the organized process of creating software, from its inception to obsolescence.

Software engineers broke down formally the software process into five stages:

  • Analysis
  • Design
  • Implementation
  • Testing
  • Deployment

Different software methodologies integrate these stages in their own way.

 

Analysis Stage

In the first step, we identify the whys of the software: what it will accomplish. This is done by:

  • Requirements specification
  • Use Cases/Storyboarding

Requirements specification is a document that:

  1. Details the functional (specific actions done) and non-functional (system constraints) requirements of the software.
    1. Functional example: System must authenticate user prior to servicing him/her.
    2. Nonfunctional example: System must authenticate under 1 second.
  2. Translates what the business owners want out of their software product into technical specifications as reference for the project team.
  3. Is a predictor of costs, production schedules, and risks of the software.

We record the steps of hypothetical cases of using the software called use cases. Example:

  Use Case: Eating

  1. Cat opens door.

  2. Cat pushes a dispenser button.

  3. Dispenser gives food.

  4. Cat eats food.

    Variation #1:

  5. Cat cannot open door.

  6. Cat waits for customer service.

  7. Continue with step 2.

Storyboarding is basically use cases but pictorially illustrated. Example (from wiki):

776px-Storyboard_for_The_Radio_Adventures_of_Dr__Floyd

 

Design Stage

Here, we plan what classes of objects will exist in the software and what each class is responsible for. This is done with:

  • CRC cards
  • Class diagrams
  • Sequence diagrams
  • State diagrams
  • Outlines in Javadoc

CRC cards are paper index cards used to identify:

  1. Classes that will exist in your program (usually the nouns found in the analysis stage)
  2. Responsibilities of those classes, ie. the methods (usually the verbs)
  3. Collaborators of each responsibility (which other classes are involved in each method)

crccard

Class diagrams are tables showing classes, their variables and methods, and relationships between them using arrows:

RELATIONSHIP Description Arrow Human Class Example
Aggregation Has as instance/class variable, “has-a” aggregation Has Arm
Dependence Manipulates, “uses” dependence Uses Food
Inheritance Subclasses, “is-a” inheritance Is Animal
Implementation Implements interface implementation Implements Worker

Example:

372px-KP-UML-Generalization-20060325_svg

Sequence diagrams show the timeline of a typical program run, in method calls (and optionally their return values). Example:

sequencediagram

State Diagrams show a program in different states with actions between them. Example:

statediagram

Outlining in Javadoc is writing Javadoc comments before blank classes and methods (“a program skeleton”) that would be filled out in the implementation stage. Example:

/** Cat.
     @author David Hsu
*/
class Cat
{
     /** Say something.
          @param what what to say.
     */
     void say(String what)
     {
     }

     /** Sleep.
          @param minutes number of minutes to sleep.
     */
     void sleep(int minutes)
     {
     }
}

 

Implementation Stage

Here, we give substance to the design of the previous stage by means of programming code.

Implementation may only result in a prototype (“earliest-type”), meaning incomplete software, but may still be runnable and it can be built on later.

 

Testing Stage

Here, we test the implemented product in all its aspects to ensure that each works properly.

Different kinds of testing exist, including:

  • Unit – testing each module of a software separately, to ensure it is working properly.
  • Regression – re-testing a software when a new feature has been added, to ensure it broke nothing that is older.

 

Deployment Stage

Here, the software product is released to the targeted audience.

This may include both installing and configuring the product on target systems.

 

Methodologies

Methodologies have been created to involve the above software stages in different ways to suit different software, most famously:

 

Waterfall Methodology

waterfall

The software process steps are done in sequence, but no step can be returned to after finishing it.

Its disadvantage is risk, because steps are often mistaken for finished when it really isn’t.

Its advantages are simplicity (and thus manageability) and suitable use in small projects where requirements are well understood.

 

Evolutionary Methodology

The software process steps are done in order, and any of those steps can be revisited at any time, as opposed to Waterfall.

 

Spiral Methodology

spiralmodel

The waterfall model but with all the steps repeated some number of times.

The products of the first few cycles are called prototypes (“earliest types”). A user interface prototype is common for this.

 

Extreme Methodology

This is a methodology that simplifies development by removing formal practices and focusing on the “best practices”, including:

  • Minimalizing the software (removing unnecessary things)
  • Refactoring (simplifying) code
  • Conforming to readable coding standards
  • Pairing programmers for tasks
  • Re-testing the whole software whenever a new feature is added
  • Scheduling consistent work hours to stabilize progress
Please like & share:

SEO Tips and Tricks

SEO

SEO Tips and Tricks:
There are hundreds of things you can do to make your website attract more and better traffic. Here are a few simple but valuable SEO tips and tricks.

To keep robots away from a single page:
< meta name = “robots” content = “noindex”/>

To instruct robots to index a page but not to follow any of its links :
:< meta name = “robots” content = “nofollow”/>

 To access an old copy of a web page:
Cache: www…….

To remove a web page from Google’s cache:
www.google.com/webmasters/tools/remove

The following is from Glenn’s excellent viperchill.com tutorial on SEO for WordPress:
“Instead of leaving things this way, I personally like to remove the blog name altogether. This isn’t  just because I think it looks better, but because it works. A client I worked with last year received a massive boost in search traffic when we removed their brand name from title tags on their blog posts.”

 The following is from MarketingSherpas  “the Ultimate SEO checklist for Small Businesses.” At
Check browser compatibility. Your site should work on the last several editions of Mozilla Firefox, Internet Explorer, and Safari, on both a Mac and a PC.

•    Remember that the more technical aspects of SEO are only part of the equation – Google and human visitors alike reward high quality, engaging content. SEO isn’t about somehow tricking search engines into driving traffic to your site – it’s simply the way that gets relevant content to as many readers as

•    Start thinking about how you’ll turn visitors into leads and leads into conversions once you get them to your site.Start out by optimizing for the most effective, popular keywords. Apart from how often keywords are searched, how local they are, and how competitive they are, one thing to consider is intent. For example, a person searching for cake decorators” is more likely to be looking to hire a cake decorator than a person searching for “cake decorating,” who may just be looking for general information.

 

 

Please like & share:

Important Basics for a WordPress Blog

October 14, 2014

5 Things You May Forget When Launching a WordPress Website

 …here are some important basics for a WordPress Blog…

from marketblog.envato.com

By Eric Karkovack

Eric Karkovack is a web designer with well over a decade of experience. You can visit his business site here. In July 2013, Eric released his first eBook:Your Guide to Becoming a Freelance Web Designer. He also has an opinion on just about every subject. You can follow his rants on Twitter @karks88.

So, you’ve just launched your new WordPress powered website. You carefully chose a theme, added some cool plugins and content. Great job!

But, are you forgetting anything? Sometimes we’re in such a hurry to get things up and running that we forget some small (but nonetheless important) details.

Here are 5 things you’ll want to make sure are taken care of:

1. Dig into the Settings Menu

The Settings menu inside the WordPress Dashboard has some of these aforementioned details that are often overlooked.

Settings > General
Make sure that the Site Title and Tagline fields are properly filled out. Nothing looks more unprofessional than the old “Just Another WordPress Site” appearing in the browser’s title bar (or worse yet, search engine results).

Also make sure that you have set the correct Timezone andDate/Time formats. You wouldn’t want the wrong dates or times showing up in your blog post, right?

Settings > Discussion
Many sites these days aren’t using the WordPress comment capabilities. Give this page a visit and make sure the settings reflect your preferences.

Settings > Permalinks
Ensure that your new site is using a nice, SEO-friendly permalink structure. Pretty much any setting outside of the default should do just fine.

2. Don’t Forget the SEO

There are plenty of SEO plugins available for WordPress. Make sure to take advantage of one! While your theme may have come with some rudimentary SEO tool, optimizing individual pages and posts will allow you to boost your rankings.

If your site has any particular content that you don’t want indexed, SEO plugins can help with that as well.

While you’re at it, you’ll definitely want to sign your site up for both Google Analytics and Google Webmaster Tools (we published a post recently covering the basics of Webmaster Tools ). These tools are essential for tracking how well you’re doing with SEO along with any marketing efforts you have made for your site.

3. Have an Emergency Plan

No matter how unlikely it seems, your site could be lost at any moment. The combination of a server crash and a web host’s corrupt backup file could mean starting from scratch again.

That’s why you need to have an emergency plan in place. Be proactive:

Regularly Back Up Your Site, Especially the Database
There are lots of great plugins out there that will help you back up your database. Some will even email pre-scheduled backups to you or a 3rd party cloud storage service. Don’t just rely on your web host to take care of this. Having the ability to restore your site’s database in the event of a crash is priceless.

Keep a Local Copy of Important Files
If you have FTP access to your website, take advantage and download all of your WordPress-related files. The/wp-content/ folder is especially important. This contains your theme, plugins, uploaded media and other vital data.

4. Stay Secure

The folks who work on the WordPress core do a great job of patching security holes rather quickly. These days, the software will even update itself when a new fix is released. But that doesn’t mean we can ignore security altogether.

There are some great security-related plugins out there that can make your WordPress site harder to hack. Especially look for plugins that will “lock out” a user after a number of failed login attempts. That can slow down bots who attempt brute-force attacks on your site. The sad thing is that those attackswill happen. It’s only a matter of time. The good news is that you can help protect your site from them.

And, don’t forget, the more complicated password/passphrase you use – the better!

5. Use a Child Theme

This is one tip that may sound like it’s for really advanced WordPress users. To some degree, it is. But it’s something I’ve seen a lot of site owners overlook (mostly because they’re unaware of it).

A child theme is a separate folder within your/wp-content/themes/ directory. Think of it as a sort-of extension of the “parent” theme your site is using. You can use a child theme to customize the look or functionality of your site.

So what’s the benefit of having a child theme? Oftentimes, theme developers will release updates (much like plugins are updated). The child theme ensures that you won’t lose any customizations made to your theme when these updates are made. Imagine having made some updates to a theme file or stylesheet, only to see them disappear after you click that Update button. This is another way to protect yourself from an unwelcome situation.

Depending upon your experience level, a child theme can be pretty easy to setup. If you hired a web designer/developer to create your site, ask them if you should be using one.

Wrapping Up

Launching your new site is a very exciting and even tense time. You want to make sure the site looks and functions perfectly. Taking the time to focus on the details can make a huge difference.

Browse WordPress Plugins on CodeCanyon →

Featured Image: Design and Development

Learn Something New October 14, 2014

5 Things You May Forget When Launching a WordPress Website

So, you’ve just launched your new WordPress powered website. You carefully chose a theme, added some cool plugins and content. Great job!

But, are you forgetting anything? Sometimes we’re in such a hurry to get things up and running that we forget some small (but nonetheless important) details.

Here are 5 things you’ll want to make sure are taken care of:

1. Dig into the Settings Menu

The Settings menu inside the WordPress Dashboard has some of these aforementioned details that are often overlooked.

Settings > General
Make sure that the Site Title and Tagline fields are properly filled out. Nothing looks more unprofessional than the old “Just Another WordPress Site” appearing in the browser’s title bar (or worse yet, search engine results).

Also make sure that you have set the correct Timezone andDate/Time formats. You wouldn’t want the wrong dates or times showing up in your blog post, right?

Settings > Discussion
Many sites these days aren’t using the WordPress comment capabilities. Give this page a visit and make sure the settings reflect your preferences.

Settings > Permalinks
Ensure that your new site is using a nice, SEO-friendly permalink structure. Pretty much any setting outside of the default should do just fine.

2. Don’t Forget the SEO

There are plenty of SEO plugins available for WordPress. Make sure to take advantage of one! While your theme may have come with some rudimentary SEO tool, optimizing individual pages and posts will allow you to boost your rankings.

If your site has any particular content that you don’t want indexed, SEO plugins can help with that as well.

While you’re at it, you’ll definitely want to sign your site up for both Google Analytics and Google Webmaster Tools (we published a post recently covering the basics of Webmaster Tools ). These tools are essential for tracking how well you’re doing with SEO along with any marketing efforts you have made for your site.

3. Have an Emergency Plan…

read more at http://marketblog.envato.com/learn-something-new/forget-when-launching-a-wordpress-website/

 

Please like & share:

Print shortcut

These alternative ways help print to console faster and, thus, debug and other actions faster by shorter typing:

 

  • Use the import static statement:
import static java.lang.System.out;

To print, call:

out.println(something);

 

  • Another way is to write this method in whatever class you want to print something from:
static void say(Object o)
{
     System.out.println(o);
}

This acts like a proxy method to System.out.println(), which is no different at all from it, just a shorter name (you can also choose your own name of course).

You can now print by writing:

say(something);

 

  • If you need to use this method often, you can write it inside a new, preferably with a short name, class:
class I
{
     static void say(Object o)
     {
          System.out.println(o);
     }
}

 

Hope this will increase your productivity!

Please like & share:

How to Implement Undo/Redo in Java

Undoing and redoing can be implemented in your programs by using the Command pattern. The Command pattern is a design pattern where objects represent commands. That is, objects contain some statements to be executed. These statements operate on some data to change its state.

To add undo functionality, add another set of statements changing the state of the data to the way it was before. This is easy to do and can be done in a few steps.

 

1.     Make an interface with two methods, undo() and redo().

Example:

interface UndoableCommand
 {
        void undo();
        void redo();
 }

 

2.     Create a class implementing it, which does your desired command. For example, UndoableListAdd, which undoes adding to a List. Any command you wish is acceptable, except that the data that is operated on must be mutable (that is, objects and not primitives).

Example: a class that will erase an element from an array, with what variables it should hold.

class UndoableErase implements UndoableCommand
 {
        //variables saving array, index to erase, and element.
        Object[] array;
        int index;
        Object oldval;
 }

 

3. In constructor, assign the data to instance variable(s).

Example: the constructor for my class would save array and its state details of old element and index to erase and apply erase operation (unset array slot at index). It takes an array and an index as arguments to the constructor.

        UndoableErase(Object[] array, int index)
        {
               //save the array and index to erase.
               this.index = index;
               this.array = array;
               this.oldval = array[index];
 
               //erase.
               array[index] = null;
        }

 

4. In undo(), set saved data to its old state (before the command).

Example: the undo() command for my class sets the array to old state (set element at index to old element).

        public void undo()
        {
               array[index] = oldval;
        }

 

5. In redo(), set saved data to its new state (after the command).

Example: the redo() for my class would set the array to new state (unset array slot at index).

        public void redo()
        {
               array[index] = null;
        } 

(Note: executing the command is the same as calling redo())

My example put together looks like this:

class UndoableErase implements UndoableCommand
 {
        //fields saving array, index to erase, and element.
        Object[] array;
        int index;
        Object oldval;
 
        UndoableErase(Object[] array, int index)
        {
               //save the array and index to erase.
               this.index = index;
               this.array = array;
               this.oldval = array[index];
 
               //erase.
               array[index] = null;
        }
 
        public void undo()
        {
               array[index] = oldval;
        }
 
        public void redo()
        {
               array[index] = null;
        }
 }

The tester for my example looks like this:

class Tester
{
    public static void main(String[] args)
    {
         //make array.
         Object[] array = new Object[] {1, 2, 3};
 
         //apply operation on it.
         UndoableOp op = new UndoableErase(array, 1);
         System.out.println(Arrays.toString(array)); //[1, null, 3]
 
         //undo that.
         op.undo();
         System.out.println(Arrays.toString(array)); //[1, 2, 3]
 
         //redo that.
         op.redo();
         System.out.println(Arrays.toString(array)); //[1, null, 3]
     }
}
Please like & share: