MatrixAdapt | Logiciel de gestion d'Entreprise, Création et référencement des sites web

Cara Membuat Template Blog SEO Friendly - Saat ini sudah banyak beredar template blog yang SEO friendly, hanya saja banyak orang tidak suka dengan desain template yang tersedia.... Kalau sudah begitu...ya apa boleh buat, sekalian saja buat template blog SEO friendly sendiri....



Berhubung banyak teman-teman blogger yang tidak tahu caranya, jadi di sini saya akan membagi beberapa tips. Hanya

Seo Master present to you: This post is part of the Who's @ Google I/O, a series of blog posts that give a closer look at developers who'll be speaking or demoing at Google I/O. This guest post is written by Jonathan Howard, lead developer of Drawloop Technologies and one of the creators of DDPs for Google Apps, a cloud based document automation service. DDPs for Google Apps will be demoing as part of the Developer Sandbox.

One of the first comments we received upon releasing our dynamic document packages (DDPs) for Google Apps was the lack of mail merge anywhere in the cloud. A DDP combines one or more documents together while also merging data into those documents, giving you a combined file with whatever page order you'd like. What we were missing from this was a simple way of getting multiple sets of data into this DDP quickly and easily. The business need was clearly there, and wasn't being filled. Google Apps provides not only an excellent document management system, but also a set of great APIs that can be utilized by third parties to expand upon the already robust offerings within Google Docs. Never ones to back down from a challenge, we set out to determine the requirements for a cloud-based mail merge solution.

1. Nothing local. Like any cloud-based solution, the only thing that should be required from a user is a solid internet connection. Their interactions shouldn't rely on installing software or using a machine with a specific set up. Our experiences from implementing DDPs for Google Apps served us well here, as we already were interacting with Google Docs.

2. Simple to manage and run. We wanted to keep the management piece as close to what already existed as possible. This meant utilizing as much of our work on DDPs for Google Apps intact, and wrapping the mail merge piece around it. At runtime, the user shouldn't have to deal with complicated forms or having to connect files together like is the norm for desktop applications.

The first problem was easily solved by extending our existing implementation with Google Docs. Leveraging Google APIs, we are able to use Google Docs for both management of the mail merge and storage of the results. Since we wanted the management to leverage our existing technology and to be both simple and entirely based in the cloud, we decided it would be best to make it wrap around our existing DDP functionality. To manage the merge data, we create a folder inside Google Docs and place within that folder a single spreadsheet. All data for a merge can be placed in that spreadsheet, which we then tie directly to the existing DDP at runtime. Each row is now considered a single DDP run with all the results streaming back to Google Docs.



One of the biggest values of utilizing a Google spreadsheet for managing the mail merge as you have all the same functions as you normally have with spreadsheets, such as Google forms. You can easily tie a form to the mail merge spreadsheet and allow your own customers to populate your data for you.

You can install your free trial of DDPs for Google Apps by visiting the Google Apps Marketplace and clicking on the "Add it now" button.

If you have questions or ideas you'd like to share on this or any of our other offerings, please visit us this week in the Developer Sandbox at Google I/O!

Posted by Jonathan Howard, Lead Developer of Drawloop Technologies 2013, By: Seo Master

Seo Master present to you: This post is part of the Who's @ Google I/O, a series of blog posts that give a closer look at developers who'll be speaking or demoing at Google I/O. This guest post is written by Brian Dorry from LTech who is demoing as part of the Developer Sandbox.

Having trouble implementing search on your App Engine Data Store? Try this technique for a basic search until official full text support is ready.

Since adding Google App Engine to our technical tool belt in 2008, we at LTech have utilized the platform for a wide range of products and customer solutions. It is cost effective, easy to use, and will automatically scale your application on Google's immense infrastructure. Knowing your applications will be running on the same technologies that Google's own systems take advantage of make it the easy choice again and again.

From our own experiences and participation in the developer community, the biggest complaint we hear is the lack of a full text search in the datastore. Google has marked this issue as "Started", but has not announced a release date yet, so alternative approaches are still going to be in play for the short term. We are big fans of Lucene (http://lucene.apache.org/), an open source indexing and search engine, but without the ability to save the index file to disk, it becomes a non-starter.

We need a quick, non-CPU taxing solution that still takes advantage of the Google infrastructure.

Problem
Taking advantage of the App Engine Datastore, we can issue an inequalities query to perform a basic "starts with" search. This can be a good solution for searching users, tags, and domains and works well for implementing a search box auto-complete feature.

Solution
Our example solution uses JDO to generate a query that instructs the DataStore to return all records that start with the search string. This is accomplished by issuing a greater than or equal condition against the search term, and a less than condition against the search input concatenated with the unicode replacement character ('\ufffd'). The resulting query limits results to items that start with the search input, as well as any other unicode characters that follow.

This code uses JDO behind the scenes, but this trick will work with straight GQL as well. Let's take a look at the sample:

import java.util.List;
import javax.jdo.PersistenceManager;
import javax.jdo.Query;

(...)

public static List searchGreeting(String query) {

  // let's clean up the input
  query = ( query != null ? query.toLowerCase() : "").trim();

  PersistenceManager pm = PMF.get().getPersistenceManager();
  Query q = pm.newQuery(Greeting.class);

  // set the filter and params
  q.setFilter("content >= :1 && content < :2");

  // run query with param values and return results
  return (List) q.execute(query, (query + "\ufffd"));

}

This code snippet is going to search the JDO defined Employee entity on the name column and return the full Employee payload for each match. Let's focus on the last two lines of code.

q.setFilter("name >= :1 && name < :2");

Here we set up the inequality. We are asking the data store to return all matches where name is between a set of two values. But how does that define a search?

return (List) q.execute(query, (query + "\ufffd"));

When we set our parameters, we pass the same query value to both with an extra character on the end of the second one. This is essentially telling the data store to return all records that start with the query term. In terms of sets, the first part of the query returns the set of all words greater than the query term, including words that don't even start with the query term. The second part of the query returns the set of all words less than the query term including any that start with the query term. The intersection of the two sets is the search result for all words starting with the search term.

This simple to implement technique will solve many basic search problems until a full text solution is available. It will work outside of JDO as well with regular GQL statements. For a python implementation, please see our friend Graeme's blog.

Posted by Brian Dorry, LTech team2013, By: Seo Master