Archive for October, 2009

Nz-Mu

Thursday, October 29th, 2009

97x+S2 Kvieciamia visus prisijunkti

Tags:
Posted in Free PHP Scripts | No Comments »

devendra

Thursday, October 29th, 2009

Tags:
Posted in Free PHP Scripts | No Comments »

151 Air, Web and iPhone Apps for Web Developers

Wednesday, October 28th, 2009

It seems like you can’t go two yards without bumping into apps these days. Whether it’s iPhone apps, web apps, or even Adobe Air apps – when used judiciously they certainly can boost your productivity and workflow. Of course over-apping has it’s dangers as my over encumbered Firefox will tell you! Still there is something mightily addictive about adding more and more awesome little tools to your arsenal.

On our sister blogs Web.AppStorm and Mac.AppStorm we’ve been running a series on apps and browser add-ons for web designers and developers. If that sounds like your cup of tea, be sure to head over and check out:

And on the subject of over-apping, here’s a comic from Mac.AppStorm’s Mactastik strip:


Tags: , , ,
Posted in PHP Tutorials | No Comments »

Top 40 Tuts+ Tutorials in September

Wednesday, October 28th, 2009

In this Best of Tuts+ roundup you’ll learn how to simulate a sniper scope, design and code a flexible website, create an intense movie poster, create a golden vector compass, build a minigolf game with ActionScript 3.0, take sports photos like a pro, create a rocky video game terrain in Blender and get a useful introduction to home recording–among many other things! Let’s take a look.

Aetuts+ – After Effects Tutorials

Nettuts+ – Web Development Tutorials

Psdtuts+ – Photoshop

Vectortuts+ – Vector & Illustrator

Activetuts+ – Flash, Flex & ActionScript Tutorials

Phototuts+ – Photography & Post-Processing Tutorials

Cgtuts+ – CG Tutorials

Audiotuts+ – Audio and Music


Tags: , , ,
Posted in PHP Tutorials | No Comments »

Secure SMTP client

Wednesday, October 28th, 2009

Connecting to Gmail and sending a message. (verbose output)
Package:
Secure SMTP client
Summary:
Send messages via SMTP server with authentication
Groups:
Email, Networking, PHP 5
Author:
wooptoo
Description:
This class can be used to send messages via SMTP server with authentication.

It can connect to a given SMTP server using SSL or TLS, and authentication using the LOGIN method.

It can send send a message with a given subject from a given address to a given recipient.


Tags: ,
Posted in Classes | No Comments »

WordPress as a CMS: New Plus Tutorial

Wednesday, October 28th, 2009

When most people think about WordPress, they think about blogs. If you look at the front page of WordPress.org, they talk a lot about blogging as well. What they don’t tell you is that WordPress can also double as a very powerful CMS; you just have to set it up properly. It can be a bit tricky to get setup and working the way that you want; but this is where I come in.

In this 3-part tutorial + screencast series, I’m going to take you through the three steps of using WordPress as a CMS. Become a PLUS member.

Join Tuts Plus

NETTUTS+ Screencasts and Bonus Tutorials

For those unfamiliar, the family of TUTS sites runs a premium membership service called “TUTSPLUS”. For $9 per month, you gain access to exclusive premium tutorials, screencasts, and freebies from Nettuts+, Psdtuts+, Aetuts+, Audiotuts+, and Vectortuts+! For the price of a pizza, you’ll learn from some of the best minds in the business. Join today!



Tags: , , ,
Posted in PHP Tutorials | No Comments »

Easy Version Control with Git

Wednesday, October 28th, 2009

Have you ever worked on a project that was so unwieldy, you were scared to update a file or add a feature? Maybe the problem was that you weren’t using a version control system. In today’s tutorial, we’ll learn the basics of what might possibly be the best VCS in the world: Git.

What is Git?

Git is a open-source code managemen tool; it was created by Linus Torvalds when he was building the Linux kernel. Because of those roots, it needed to be really fast; that it is, and easy to get the hang of as well. Git allows you to work on your code with the peace of mind that everything you do is reversible. It makes it easy to experiment with new ideas in a project and not worry about breaking anything. The Git Parable, by Tom Preston-Werner, is a great introduction to the terms and ideas behind Git.

Why Should I use Git?

You should definitely use a revision control system; as we already said, this gives you the freedom to do whatever you want with your code and not worry about breaking it. So if you’ve realized the benefits of using a revision control system, why should you use git? Why not SVN or Perforce or another one? To be honest, I haven’t studied the differences too closely; check out WhyGitIsBetterThanX.com for some helpful info.

How do I Get Set Up?

Git is pretty easy to get: on a Mac, it’s probably easiest to use the git-osx-installer. If you have MacPorts installed, you may want to get Git through it; you can find instructions on the GitHub help site. (And yes, we’ll talk about GitHub). On Windows, the simplest way to start rolling is to use the msysgit installer. However, if you’ve got Cygwin, you can git Git through there as well.

How do I use Git?

By now you should have Git installed; if you’re on a Mac, open up a terminal; if you’re on Windows open the Git Bash (from msysgit) or your Cygwin prompt. From here on, there shouldn’t be any OS differences.

Configuration

We’ll start by doing a bit of configuration. Every commit you make will have your name and email address to identify the ‘owner’ of the commit, so you should start by giving it those values. To do so, run these commands:

git config --global user.name "Your Name"
git config --global user.email "your@email.com"

It’s also nice to enable some text coloring, just for easier reading in the terminal. 

git config --global color.diff auto
git config --global color.status auto
git config --global color.branch auto

git init

Now that Git knows who you are, let’s imagine we’re creating a simple PHP web app. (Of course, the bigger the project, the brighter Git shines, but we’re just learning the tools, right?) We’ve got an empty directory called ‘mySite.’ First focus on that directory (using the cd command). To get started with Git, you need to run the git init command; as you might guess, this initializes a Git repository in that folder, adding a .git folder within it. A repository is kind of like a code history book. It will hold all the past versions of your code, as well as the current one.

Git Init

Notice that your terminal path is appended with (master). That’s the branch you’re currently working on. Branch? Think of your project as a tree; you can create different features on different branches, and everything will stay separate and safe.

git add

We’ve started working on our application.

Files

Before we go any further, we should make our first commit. A commit is simply a pointer to a spot on your code history. Before we can do that, however, we need to move any files we want to be a part of this commit to the staging area. The staging area is a spot to hold files for your next commit; maybe you don’t want to commit all your current changes, so you put some in the staging area. We can do that by using the add command

git add .

The . simply means to add everything. You could be more specific if you wanted.

git add *.js
git add index.php

git commit

Now that we’ve staged our files, let’s commit them. This is done with the command

git commit

This takes all the files in our staging area and marks that code as a point in our project’s history. If you don’t add any options to the command above, you’ll get something like this.

vim

Each commit should have an accompanying message, so you know why that code was committed. This editor allows you to write your message, as well as see what is in this commit. From the image above, you can see that this commit is comprised of four new files. The editor you’re using to write the message is Vim; if you’re not familiar with vim, know that you’ll need to press i (for Insert) before you can type your message. In the shot above, I’ve added the message “Initial Commit.” After you write your message, hit escape and type :wq (to save and exit). You’ll then see you’re commit take place.

Commit Aftermath

You can use a few options to make commits more quickly. Firstly, -m allows you to add your message in-line. 

git commit -m "initial commit"

Then, -a allows you to skip the staging area; well, not really. Git will automatically stage and commit all modified files when you use this option. (remember, it won’t add any new files). Together, you could use these commands like this: 

git commit -am 'update to index.php'

So how does Git tell commits apart? Instead of numbering them, Git uses the code contents of the commit to create a 40 character SHA1 hash. The neat part about this is that, since it’s using the code to create the hash, no two hashes in your project will be the same unless the code in the commits is identical.

git status

The git status command allows you to see the current state of your code. We’ve just done a commit, so git status will show us that there’s nothing new.

status, clean

If we continue working on our imaginary project, you’ll see that our status changes. I’m going to edit our index.php and add another file. Now, running git status gives us this:

Status, not clean

The update is divided into two categories: “changed but not updated,” and “untracked files.” If we run 

git add userAuthentication.php
git status

you’ll see that we now have a “changes to be committed” section. This lists files added to the staging area. I’m going to commit these changes with this: 

git commit -am 'user authentication code added'

Now running git status shows us a clean working directory.

git branch / git checkout

Here’s a scenario: we’re working happily on our project when suddenly we have a grand idea. This idea is so revolutionary, it will change our project drastically. We’ve got to give it a try, but we don’t want to throw this insecure, first-draft code in with our tested and true code. What to do? This is where git branch will be immensely helpful. Let’s branch our project so that if our big idea doesn’t work out, there’s no harm done.

git branch

Just running the branch command sans options will list our branches; right now, we’ve only got the master branch, which is what any git repository starts with. To actually create a new branch, add the name of your new branch after the command.

git branch bigIdea

When you create a new branch, you aren’t switched to it automatically. Notice that our terminal still says (master). This is where we use branches comrade command git checkout.

git checkout bigIdea
Git Branch

(Tip: you can create a branch and switch to it in one fell swoop with this command: git checkout -b branch name.) As you can see, we’re now on the bigIdea branch. Let’s code up a storm. Git status will show our work.

2 new files

Let’s commit our changes: 

git add .
git commit -m 'The Kiler Feature added'

All right, enough of this feature for now; let’s go back to our master branch; but before we do, I want to show you our current project folder.

Files, branch bigIdea

Now, switch back to the master branch; you know how:git checkout master. Look at our project folder again.

Files, branch master

No, I didn’t do anything; those two files are only part of the bigIdea branch, so we don’t even know they exist from the master branch. This not only works for complete files, but also for even the smallest changes within files.

git merge

Ok, so we’ve been working hard on that bigIdea branch in our spare time. In fact, after another commit, it’s looking so sweet we’ve decided it’s good enough to join the master branch. So how do we do it?

The git merge command is made for exactly this purpose. While on the master branch, give this a try:

git merge bigIdea

It’s that easy; now, everything on the bigIdea branch is a part of the master branch. You can get rid of the bigIdea branch now, if you want. 

git branch -d bigIdea

I should mention that if you haven’t merged a branch, Git won’t let you delete it with this command; you’ll need to use an uppercase D in the option. This is just a safety measure.

git log / gitk

You’ll probably want to look at your commit history at some point during your project. This can easily be done with the log command. 

git log

This will output a list of all the commits you’ve made in a project, showing them in reverse order. You can get at quite a tidy chunk of info here:

git log

Definitely informative, but rather dry, no? We can brighten things a bit with the graph option.

git log --graph
git log --graph

Now we can see the tree structure, sort of. Although we don’t get their names, we can see each of the branches and which commits were made on them. If you’re used to working in a terminal, you might be fine with this. However, if (previous to this experience) the word terminal strikes you first as something deadly, breathe easy: there’s an app for that. Try this: 

gitk --all
gitk

This is the graphical repository browser. You can browse around your commits, see exactly what was changed in each file during a commit, and so much more. (You’ll notice I added a few commits before merging, just to make the tree structure more recognizable.)

GitHub

Now that you’ve got a reasonable knowledge of Git under your belt, let’s look at some of the collaborative parts of Git. Git is a great way to share code with others and work on projects together. There are a number of Git repository hosting sites. We’ll just look at one: GitHub.

GitHub Home Page
GitHub Sign Up

Head over to the GitHub sign-up page and create an account. You’ll need an SSH public key, so let’s create that right now! (Note: you don’t need the key while signing up; you can add it later.)

Open up your terminal and type this: 

ssh-keygen -t rsa -C "your@email.com"
ssh

The t option assigns a type, and the C option adds a comment, traditionally your email address. You’ll then be asked where to save the key; just hitting enter will do (that saves the file to the default location). Then, enter a pass-phrase, twice. Now you have a key; let’s give it to GitHub.

First, get your key from the file; the terminal will have told you where the key was stored; open the file, copy the key (be careful not to add any newlines or white-space). Open your GitHub account page, scroll to SSH Public Keys, and click “Add another public key.” Paste in your key and save it. You’re good to go! You can test your authentication by running this: 

ssh git@github.com

You’ll be prompted for your pass-phrase; to avoid having to type this every time you connect to GitHub, you can automate this. I could tell you how to do this, but I’d probably inadvertently plagiarize: the GitHub Help has a plain-english article on how to do it.

Git Clone

So now you’re set up with GitHub; let’s grab a project. How about jQuery? If you go to the jQuery GitHub project, you’ll find the git clone URL. Run this: 

git clone git://github.com/jquery/jquery.git
git clone

This creates a jquery folder and copies the whole jquery repository to your computer. Now you have a complete history of the project; check it out with gitk –all.

git push

So let’s say you’ve been working on a project, managing it with git locally. Now you want to share it with a friend, or the world. Log into GitHub and create a new repository. GitHub will give you a public clone URL (for others wanting to download your project) and a personal clone URL (for yourself).

Create New Repository

Then, come back to your project in the terminal and give this a whirl:

git remote add origin git@github.com:andrew8088/Shazam.git

A remote is a project repository in a remote location. In this case, we’re giving this remote a name of origin, and handing it our private clone URL. (Obviously, you will have to substitute my URL for your own.) Now that the project knows where it’s going . . .

git push origin master
Git push

This pushes the master branch to the origin remote. Now you’re project is available to the world! Head back to your project page and see your project.

GitHub Project

git pull

You might be on the other end of a project: you’re a contributor instead of the owner. When the owner pushes a new commit to the repository, you can use git pull to get the updates. Git pull is actually a combo tool: it runs git fetch (getting the changes) and git merge (merging them with your current copy). 

git pull

You’re Set!

Well, there’s so much more you can learn about Git; hopefully you’ve learned enough commands to help you manage your next project more smartly. But don’t stop here; check out these resources to become a Git master!



Tags: , , ,
Posted in PHP Tutorials | No Comments »

Chatr - simple Ajax/Php chat

Wednesday, October 28th, 2009

Another simple ajax chat application with limited functionality built in PHP

Tags:
Posted in Free PHP Scripts | No Comments »

Plugin Compatibility Beta

Wednesday, October 28th, 2009

The number one reason people give us for not upgrading to the latest version of WordPress is fear that their plugins won’t be compatible. As part of our continuing efforts to make WordPress core, plugin, and theme upgrades as painless as possible, Michael Adams developed and launched a beta of a new “Compatibility” feature in the plugin directory, powered by your votes. When viewing a plugin in the directory, select a WordPress version and a plugin version from the drop-downs. If there has been feedback about this WordPress / plugin version combination, we’ll show you what percentage of responses marked that combination as compatible vs how many marked it as incompatible.

Compatibility: Your Setup: (WordPress Version drop-down) (Plugin Version drop-down). Log in to vote. The Concensus: 44% negative, 56% positive

If you log in, you’ll be able to help us gather this information! Just select a WordPress version / plugin version combination and click the “Works” or the “Broken” button. Please note that this shouldn’t be used to report minor issues with a plugin. You should mark a plugin as “Broken” only if its core functionality is truly broken when run on the specified WordPress version.

Compatibility: Your Setup: (WordPress Version drop-down) (Plugin Version drop-down). (Broken button) (Works button). The Concensus: No data

Right now we’re just in information gathering mode. So get out there and vote! Don’t just vote on broken plugins… cast a “Works” vote for every plugin that works on the version of WordPress you are using. This can help improve the signal-to-noise ratio in our data and prevent a few mistaken “Broken” votes from weighing too heavily.

For developers, we’re now including this data in our API. The plugin_information action now returns a “compatibility” member with the multidimensional array format:

array( {WP version} => array( {plugin version} => array( {% of reporters who say it works}, {# responses} ) ) )

If the API knows which version of WordPress you are using (for example, if you are making this query using the plugins_api() function from with WordPress), the API will only return compatibility information for your version of WordPress.

Eventually, we’d like to gather this compatibility feedback from within WordPress, allowing you to vote directly from your plugins admin screen. The ultimate goal is to use this information to inform you of plugin incompatibilities with a new version of WordPress during the upgrade process. For that to be useful we need a large set of high quality compatibility data. Start voting!

Tags:
Posted in Uncategorized | No Comments »

Feeds 101

Tuesday, October 27th, 2009

Feeds. RSS. Atom. Syndication. Subscribers. These are some of the keywords floating around the web and have gained notorious prominence over the years. In this guide, we’ll take a look at a number of things including what feeds are, why you need to have a feed for your site, how to set up one and then publish it.

What are Feeds?

Feed image

In this digital age, users no longer have the luxury of time to check for new content manually each time or more importantly remember each site they want to get information from. Web feeds, news feeds or feeds helps the user simplify this process drastically.

Feeds, to put it simply, are a way to publish frequently updated content. Your feed is a XML formatted document which lets you share content with other users on the web. Users, subscribers in this lingo, can use your feed to read updated information on your site if and when it is posted.

Why you Should Publish Feeds

From a web developer’s perspective, one of the main reason for publishing a feed is user convenience. With a feed for users to subscribe to, they don’t have to check for new content manually each time. They can just subscribe to your feed and get notified new content is posted. No hassles! If you fear you’ll lose your advertisement revenues in this process, you can just as easily include ads in the feed.

Publishing a feed also means that it is easier for third party content providers to syndicate your content thus gaining more exposure and traffic in the process.

Feed Formats

As with any hot technology, there are a few well established, competing protocols for creating web feeds.

RSS

Feed image

RSS is the dominant format for publishing web feeds and stands for Really Simple Syndication. RSS has a number of variants each branching out from RSS 1.x and RSS 2.x versions. A lot of services, including WordPress use RSS for creating its feeds.

Despite it’s massive user base, RSS does suffer from some drawbacks, some significant, the most important one being its inability to handle HTML. Nevertheless, we’ll be creating our feed today in the RSS format.

Atom

Atom logo

Atom was created in order to mitigate a lot of RSS’ drawbacks including the ability to include properly formatted XML or XHTML in your feeds. But since RSS has almost become synonymous with feeds, Atom has always been the much more feature rich and flexible little brother.

RSS’s Format

In the interest of keeping it simple, we’ll just stick with RSS today instead of trying out each format out there.

Each and every RSS feed out there follows this general format:

Defining the version and encoding

RSS is a subset of XML which means we need to make sure it is marked so appropriately. 

<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
..
</rss>

The first line is the XML declaration. We define the version so that it validates correctly as XML. The encoding part is purely optional.

The second line defines the version of RSS we are going to use today. We are going to use RSS 2 today.

Each feed need to be inside a channel so that goes inside the markup. Thus far our feed looks like so.

<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
<channel>
..
</channel>
</rss>

Filling in the feed’s source information

This is where you fill in all the important details like the name of the feed, the URL and a description of the site. 

<title>My feed</title>
 <link>http://www.somesite.com</link>
 <description>Random ravings :) </description>

You aren’t limited to these fields alone. There are a number of other optional fields including the language of your feed, an image for the logo, when the feed was updated last and many more.

Adding the content

Each item in the feed has to be enclosed by an <item> element. An item can be anything: a news post, a status update, new products: anything. Each item requires a title and a corresponding link. As with before, you can make use of a number of optional elements including description and author fields.

A sample item would look like so:

<item>
<title>Feeds 101</title>
 <link>http://www.net.tutsplus.com</link>
 <description>Let's create an RSS feed from scratch!</description>
 <author>Siddharth</author>
</item>

Building a Static RSS Feed

Now that we know all the individual parts of a RSS file and how they all gel together, it’s time to see a complete RSS file. 

<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
<channel>
	<title>My feed</title>
   <link>http://www.somesite.com</link>
   <description>Random ravings :) </description>
   <item>
		<title>Feeds 101</title>
 		<link>http://www.net.tutsplus.com</link>
 		<description>Let's create an RSS feed from scratch!</description>
 		<author>sid@ssiddharth.com</author>
	</item>
</channel>
</rss>

It may not look like much but gents, this is a working RSS feed. We’ve defined everything that needs to be defined and if you are inclined to do so, you can put this on the web.

Building a Dynamic RSS Feed

Happy about building your first RSS feed? You should be! But the problem with this is that the feed is completely static: something which is completely counter intuitive as compared to the concept of feeds. We’ll rectify this now by building a simple PHP script that mooches off data from a database and updates the RSS feed when needed.

Since I like having pretty URLs, I am going to name this file index.php and place it in a folder called feed so my feed can be accessed at www.mysite.com/feed

For the sake of simplicity, I am going to assume you already have a database containing your articles. I am also assuming the database has columns named title>, link, description and date in a table called posts.

Building the base

<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
<channel>
	<title>My feed</title>
   <link>http://www.somesite.com</link>
   <description>Random ravings :) </description>

 <?php
    // Code here
 ?>

</channel>
</rss>

Since the XML declarations and feed information are going to be pretty static, we’ll keep them static. You’d want to keep them dynamic if you were writing a PHP class for generating RSS feeds but for our purposes, this should do.

Defining database information and connecting

DEFINE ('DB_USER', 'some_username');
DEFINE ('DB_PASSWORD', 'some_unusually_weak_password');
DEFINE ('DB_HOST', 'localhost');
DEFINE ('DB_NAME', 'database');

Simple as it looks. We just note down a bunch of information for use later.

$connection = mysql_connect(DB_HOST, DB_USER, DB_PASSWORD) or
die('Connection to the specified database couldn't be established');
mysql_select_db(DB_NAME)  or
die ('Specified database couldn't be selected');

Pretty generic connection code. We try to connect using the credentials noted earlier. If nothing hitches up, we select the relevant database for use later.

Querying the database

$query = "SELECT * FROM posts ORDER BY date DESC";
$result = mysql_query($query) or die ("Query couldn't be executed");

This isn’t really a SQL oriented tutorial and so I’ll skim over it. We just grab all the posts from the table so that we can add it to the feed. Nothing else fancy going on over there.

Populating the items list

while ($row = mysql_fetch_array($result, MYSQL_ASSOC) {
echo '<item>
		 <title>'.$row['title'].'</title>
		 <link>'.$row['link'].'</link>
		 <description>'.$row['description'].'</description>
	   </item>';
}

We grab each individual record and then print it inside the relevant element to create the items list. Note that since I wanted a hash to work with I set the result type to MYSQL_ASSOC.

And with that the PHP part is done. The complete code should look like below. 

 <?php
     header("Content-Type: application/rss+xml; charset=utf-8");
 ?>

 <?xml version="1.0" encoding="utf-8"?>
 <rss version="2.0">
 <channel>
	<title>My feed</title>
   <link>http://www.somesite.com</link>
   <description>Random ravings :) </description>

 <?php
    DEFINE ('DB_USER', 'some_username');
	 DEFINE ('DB_PASSWORD', 'some_unusually_weak_password');
	 DEFINE ('DB_HOST', 'localhost');
	 DEFINE ('DB_NAME', 'database'); 

	 $connection = mysql_connect(DB_HOST, DB_USER, DB_PASSWORD) or
	 die('Connection to the specified database couldn't be established');
	 mysql_select_db(DB_NAME)  or
	 die ('Specified database couldn't be selected');  

	 $query = "SELECT * FROM posts ORDER BY date DESC";
	 $result = mysql_query($query) or die ("Query couldn't be executed");  

	 while ($row = mysql_fetch_array($result, MYSQL_ASSOC) {
		echo '<item>
			 	<title>'.$row['title'].'</title>
		 		<link>'.$row['link'].'</link>
		 		<description>'.$row['description'].'</description>
	  	 	  </item>';
	 }
 ?>

 </channel>
 </rss>

You should now be able to access your feed at www.yoursite.com/feed.

Validate your Feed

Feed image

Just like with xHTML, RSS/XML needs to be well-formed and without errors. There are a number of validators to help you with this. Here are some of my often used ones.

Since RSS can only handle escaped HTML, make sure you use &lt; lt; for < and &lt; gt; for > respectively. Also make sure you replace special characters to their respective HTML codes. Forgetting to do so will probably result in invalid markup and break the feed.

All Done! Publish that Feed

Feed image

Now that we’ve created the feed and made sure it validates, we can now go publish it. You can use a service like Feedburner to manage your feeds. This lets you glean a lot of information including how many subscribers you have. Or you can take the easy way out and just link to your feed on your site.

Have you ever noticed the feed icon on your browser lighting up for certain pages alone? This means the browser has been notified that a feed of the current page is available for subscription. In order for the user’s browser to automatically detect the feed’s presence you need to add this small snippet to the head section of your page:

<link rel="alternate" type="application/rss+xml" title="Article RSS Feed"
href="http://www.yoursite.com/feed" />

You need not limit yourself to one feed. You may have a feed for each author or a feed for each category of the products you sell. Feel free to add as many feeds you want to the head section.

Conclusion

And that brings us to an end to this joy ride. We’ve gone over what feeds are, what purpose they serve and the different formats available. Next we looked at RSS, its skeleton structure and then learned how to create a simple dynamic RSS feed. Hopefully you’ve found this tutorial interesting and this has been useful to you.

Questions? Nice things to say? Criticisms? Hit the comments section and leave me a comment. Happy coding!



Tags: , , ,
Posted in PHP Tutorials | No Comments »