Friday, March 11, 2005

FIRA THE CUB, am gonna crucify u ..........

u gonna pay FIRA .......


all u guys out there in blogland.... FIRA is dead meat now ....
the looser blocked me out (and DORKO did the same)

these guys did the unpardonable ... trying to censor the net ...
am gonna follow FIRA wherever he goes .... wid a carving knife... and i wont be cutting fore skin only....


1 comment:

saby said...

my apologies FIRA and Dork

read dis:

APIs and SSL
Remain calm and do not panic. We're switching to a more secure
Google-wide account system. What does this mean? Basically, it means
that our APIs are all going to be available over SSL. We're not
turning off the old API endpoints, but tools not using SSL won't be
able to send usernames and passwords over the clear. Which pretty much
means they will seem broken.

The good news is, we're not just gonna leave you hanging. We're
building a special PIN system for use with non SSL tools. Blogger 1.0,
2.0, and Atom 0.3 are all going to be available over SSL. Since our
Atom 0.3 support is still beta, we will switch to only support HTTP
Basic Authentication over SSL. As our Blogger API support is
considered stable, we will support both regular passwords over SSL and
a new PIN system over non-SSL connections.

So users of non SSL tools will be able to visit Blogger.com and get a
special password but you'll agree this is not optimal. What we
recommend and encourage is that you, gentle Blogger developer, switch
to an XML-RPC toolkit that can do SSL and make the appropriate changes
to your fine offerings.

We're planning on initiating this move in a few weeks and we'll work
to make sure our user base understands what's going on as well. We'll
keep you updated on the BDN blog with any significant news. Please
accept our apologies if this switch messes up your weekend or causes
you any trouble but ultimately, it's for the best--think of the
possibilities!


Posted by Jason Shellen at 15:41

Thursday, January 22, 2004
Blogger gets AtomEnabled

Today, we launched support for Atom in Blogger. This means that all Blogger users now have the ability to syndicate their blog content in a rich XML format (see What is Atom?). In addition, we have rolled out beta support for the Atom API. This means a more robust API for you to use in creating new blogging applications. Some of the benefits of the new API are:

support for titles
tighter integration with the
syndication format and editing tools
extensibility
easy-to-use WSDL file to work with most SOAP toolkits
higher security authentication using WSSE
more robust Blogger endpoint
support for SOAP and REST

More documentation will follow in the next few weeks as the Atom API moves to version 1.0. In the meanwhile, you may want to try the SOAP Atom API client in C# and this WSDL file. You should be able to drop this WSDL file into most developer tools. You can test this client against our Atom API endpoint at: http://www.blogger.com/atom/. You should enter the endpoint where it currently says http://localhost/AtomApi.asmx in the WSDL. For more general Atom information visit AtomEnabled.org.

As always, feedback and comments are appreciated.


Posted by Jason Shellen at 17:24

Sunday, November 30, 2003
Atom feed limited beta
Since the Atom syndication format is nearing a spec revision, we thought we should point to examples of the feeds we are currently planning to output via Blogger. Some of the Blogger team members have graciously agreed to use their personal blogs as Atom syndication test blogs, below are a handful for testing purposes. Please remember that these are not the final output, probably close though, and should validate at FeedValidator.org. Enjoy and please leave any comments on the Atom-syntax list.

Jason Goldman : http://www.goldtoe.net/atom.xml
Steve Jenson : http://www.saladwithsteve.com/atom.xml
Jason Shellen : http://www.shellen.com/atom.xml
Evan Wiliams : http://www.evhead.com/atom.xml

Next step: Atom syndication for you!

Posted by Jason Shellen at 21:44

Tuesday, July 01, 2003
Proposal for post creation request
Misha has put up a proposal on the new API wiki for how a post request might work. Feedback welcomed there.

Posted by Ev. at 21:50

Blogger API Update
Here is an update for developers interested in writing tools that integrate with Blogger.

First, a little background: As you may know, the original Blogger API was put up almost two years ago, with the disclaimer that it was in an "experimental" and "alpha" state with no guarantees about its future. It was designed hastily by myself in a couple days, and we had very little resources to do much with it at the time.

Despite these drawbacks, people built cool stuff and other blogging tool vendors supported the Blogger API for compatibility.

It is now (past due) time to do a major revamp of our API. In fact, we've been working on the next version for quite a while. We posted a preliminary spec to our developers list late last year and got a lot of feedback. But we were not that confident in the direction and still didn't really have the extra cycles necessary to put into to it—until recently.

As the first post to this blog (which also inaugurated this new developer's section of blogger.com) indicates, we became very interested in a new proposal that has recently been in the works by a bunch of smart engineer-types of the blogging world. We felt, if it worked out, this new spec (code-named "Atom"), would solve a lot of potential problems with our API, as well as with the blog syndication format we support, RSS. It would do so in an elegant way, specifically designed for blogging. And, even better, a way that was unified with other major blogging tool vendors.

Consequently, our developers got involved with the Atom project to make sure we felt it would work for our needs, as well as everyone else's. We are very pleased with the technical progress made so far and are committed to help the project reach conclusion.

What this means for Blogger developers:

We will continue to support the Blogger API 1.0. (Technically, we are supporting it for the first time—as in, taking off the disclaimers and making sure it is up and running more reliably.) In fact, we have written a new implementation of it, along with the new, more robust, Blogger codebase. However, that spec is frozen and will not be developed further.


We will not be implementing or supporting the Blogger API 2.0. We apologize for having that out there in a semi-final looking spec for so long. We know it was frustrating for developers. But please forget that ever happened.


We are moving away from XML-RPC. If you choose to take advantage of the capabilities of the new API, you will need to use SOAP instead of XML-RPC. This was a difficult decision (made collectively by the designers of Atom), because there is a lot of investment in XML-RPC in the blogging tool space, and it is great for getting things done quickly. But we felt the technical advantages offered by SOAP were worth the effort. (See SixApart link below for details.)


The syndication format and API format will be unified. This is one of the nice aspects of Atom that could not have been easily accomplished without starting from scratch. It generally simplifies getting data into and out of blogging apps.


Interoperability. This is a biggie. At least two other major blogging tool and service companies (SixApart and Live Journal) have pledged their support for this new initiative, and we're working with them (as well as others) to define the spec up-front. This means your tools will be usable by as many people as possible, with minimal effort. And since the API/format will be vendor-neutral, no one's needs can be more important than users and developers.

In general, our goal is to make it as painless as possible to develop neat stuff that plugs into Blogger, and we feel we are very close to having the best direction for that to happen. The technical folks in the blogging world have learned a lot of the past few years about RSS and the blogging APIs—about what works well and what doesn't. And, despite the efforts that have gone into certain directions, we feel it'd be unfortunate this early in the game to be married to a certain direction just because we started out that way when we didn't know as much.

As mentioned, the project is still in the works, and there is no final spec, but there are lots of smart people working on getting it right. And it's an open process: You can get involved by visiting the wiki, posting to your blogs and mailing lists, etc.

Lastly, I didn't go into much of the technical reasons behind the decisions in the Atom project here. But they have been well-articulated by Ben Trott of SixApart. I encourage checking out that if you're interested.

Thanks for your patience (and contributions) in getting this all worked out.

Posted by Ev. at 20:20