Join us at Open Source Bridge, June 17-19th

Oregon Blogs is presenting a community discussion workshop at the Open Source Bridge conference in Portland. We will be hosting an open forum for the entire community to present their thoughts on the Oregon blog aggregator.

This will be a moderated discussion focused on developing a set of guidelines and principles that is based on what the community wants Oregon Blogs to be. We’d like to get as much feedback from as many people as possible, so please come join the discussion and be prepared to talk about three major things:

  1. What does Oregon Blogs mean to you?
  2. What do you want to see in the new Oregon Blogs?
  3. What do you absolutely not want to see?

This is a chance for all the members of the ORBlogs community to help drive the development of the site, as such, it is focused on getting input from non-programmers in the community.

So join us at Open Source Bridge, June 17-19 at the Oregon Convention Center in Portland.

Code Sprint! March 7th at CubeSpace

The ORBlogs community is having our first code sprint on March 7th at CubeSpace, from 11am until 4pm with celebration to follow. We thank the great folks at CubeSpace for donating the space for this code sprint, so be sure to lavish them with affection!

This code sprint will be a gathering open to everyone interested in taking the current Oregon Blogs Test Site and turning it into a working digg-style blog aggregator. As Bill states:

“I would really like to encourage everyone on the list to at least consider coming to the meetup!  As I have said before: whether or not you are a programmer, we are all developers, and we should own this as a  community.  I bet you all have some valuable input as to how the site should look and flow, and you can give us coders some very useful direction.”

Details will follow shortly about the main issues we will be tackling. Stay tuned both here and on the Groups Page for more information.

Test site fixed!

Hey gang, the test site is now working correctly again.  Hooray!  If you’re interested in the details, this was the fix.

Please go ahead and create yourself an account, add plenty of (appropriate) feeds, file issues for anything that is broken or otherwise obviously wrong, and chat us up on the mailing list with ideas for improvement!  Please don’t be shy, we need as many people beating on this thing and providing feedback as we can get!

When you are adding feeds, don’t worry about the checkbox that says “I own this blog/website”.  Add any sites you like, as long as they fit within the ORBlogs purview!  I believe we will eventually be getting rid of that checkbox and the current model of feed ownership, and moving to either a curated model or a community-managed model.  I could be wrong, though.  :)

If you are already on the mailing list, you may have noticed a couple of messages from TeamCity (our continuous integration server).  I set it up to directly notify the list on most build events; I believe it helps us toward our goals of agility and transparency.  If for some unlikely reason it becomes a burden, we can always turn it off or redirect it to a secondary mailing list.  Also, if you create yourself an account on the TeamCity server and want more than just “viewer” access, let me know and I’ll hook you up!

-Bill

Getting Things Done

Hi all!  John gave me rights to post here, so I thought I would abuse the privilege for a moment.

I feel like we have been stalling a bit, so I have done a few things recently to try to make the development process more transparent, as well as easier for anyone who wants to just jump in and do what they can, but may have been stymied by not knowing where to start.

I posted on the mailing list earlier today about what I have been doing, so go ahead over there for the details, and reply on-list (my preference), in the comments here, or via Twitter if you have any questions.

By the way, go ahead and consider this another call for development help.  Anyone have some #afterhours they want to contribute to this?  ;)

Cheers,
-Bill

Help ORBlogs: Hit The Development Server!

I was supposed to write this blog post a couple weeks ago. Ugh. Holidays!

Well, we’re all back to work now that the holiday madness has ended, and that means that development is heating up again on ORBlogs. This year, Santa dressed up as Bill Jackson and left a development server under our tree. The server is at http://haxx.orblogs.org (which is a redirect currently, but we’re working on that).

Here’s a message from Bill snatched from the ORBlogs development list:

Uh, hello?  I think you have missed some tweets from both John and me; I have had a testing server running at http://haxx.orblogs.org/ for quite a while now!  :)  Apparently I did a poor job disseminating this information, I think even John didn’t realize it was actually working until last week or so.

I wrote a shell script that monitors the Subversion repository, and rebuilds/reloads the app on every checkin.  I just need to test it a bit more and add it to my crontab…

Anyway, everyone please go ahead and start using the site above for testing, and start filing bugs as you find them!

Lastly, anyone not familiar with Pencil (the Firefox plugin) should check it out; it’s awesome for doing UI mockups, web or otherwise.  Bram, I imagine you know about it already.  :)

Cheers,
-Bill

What this means is that anyone with access to the source code (i.e. working from our ORBlogs Google Code page) can hit the development server, see problems, fix them, and commit the changes.

Not a programmer? Not interested in grabbing code? No matter. Check out the development server anyway. If you see issues that need fixing, head over to Google Code Page and file a ticket. (Do us a favor and make sure someone else hasn’t already done so :).

Additionally, Bram Pitoyo has offered to work on the layout and typography. With such a master as that on board, the ORBlogs user interface is certain to be amazing. Maybe we can talk Amber Case into some great data visualizations as well (hint, hint :)

I hope everyone had a safe holiday season. With a server running, more people helping, ORBlogs 2.0 is closer than ever to being re-launched. Thanks Santa!

Hey, where did everybody go?

It’s been a bit over a month since I’ve updated the blog- which means that I’m just a really bad blog host. It’s not like nothing’s been happening, lots of things have happened. Unfortunately many of them were bad, and happened to me.

I really didn’t mean to completely desert the blog, it just sort of worked out that way, and I’m sorry. It’s not good because many folks out there are probably asking the question:

“Hey, where did everybody go?”

Well, we’re still here, and I expect it’s time you had an update about what’s going on. Unfortunately, it’s not very glamorous.

Patrick (BigBark writer) and Lyle have done major work on the back-end code and we’re now, apparently, at the stage where we need a server to have it running and have to get a few more people looking at (and testing) the codebase.

That’s where Bill Jackson comes in. Bill is setting up his server to run the current code so that people can play with it and, when things are broken, log bugs or issues when something’s wrong. This means that we’re nearly at the stage where at least something visible is presented.

It’s not magical news, but it’s actually pretty exciting for the developers. I have to say, without the dedication of Lyle, Patrick and Bill, things would be pretty sad. Because of them, we’re closer to having a Digg-able aggregator.

I’ll try to be a better blog host in the future.

Portland Java Users Group joins ORBlogs Effort

For a little while, things were starting to seem disappointing in the ORBlogs effort. I origionally shot for Oct. 1st to get the BigBark code running, giving us a near immediate availability of the aggregator and Digg ranking. However, the time I’ve spent away from Java has made that nearly impossible. So we started talking about what the best options are, and if we should step back from the BigBark code at all.

Enter Rick Turoczy (Heh, that’s a pretty well used phrase by now, innit?) with a suggestion that the ORBlogs team contact the Portland Java Users Group. A quick email calling for help, led to a number of replies in a thread available on the Google Groups page.

The short Version: Craig McClanahan came out with both barrels swinging.

The Long Version: Remember the early days of the effort- mostly taking place on Twitter and FriendFeed? No? Well, we were discussing how to make ORBlogs not just another aggregator, but a complete tool, powerful, redistributable. My suggestion was an Open Source tool that was scalable that anyone could used (MediaWiki style) but that we could also enterprise, giving ORBlogs the revenue it needs to grow. Craig suggested something very similiar, although from the perspective of a programmer. Read the thread for full details.

However, I still think that we should get BigBark running, for a number of reasons, not the least of which is that people want ORBlogs back now, and we can accomplish that. Here are my thoughts:

  • BigBark is basically ready to run. We need to dust it off and turn the key, this makes it an optimal instant, if temporary, solution. Patrick agrees with this assessement, am I right?
  • There are at least 1800 blogs currently indexed which are now not served. Many of these folks are, understandably chomping at the bit since we (i.e. I) originally shot for Oct. 1st.
  • There are a large number of blogs (I have 4 alone) that are not indexed which need to be added to ORBLogs ASAP.
  • Having BigBark up- and experiencing the slam of hundreds of bloggers hitting it with full expectation- will not only give us juice, it will give us data and information on what we want and need in the larger effort.
  • The thought was that it was a mere few days to get BigBark running with strong Java people, so it would not take away from the longer term effort.
  • Once BigBark is running, we can spend the actual time to design an excellent system while blogs are  being indexed and traffic is being generated. this will make the blogging community very happy.

I agree with Craig that we should seek the architecture like the one that he outlines, but my thought is that this will (if we do it right) will take time. As I was writing this, J-P Voillequé shot me a Twitter Post stating that he would rather wait and have something longterm and stable than something right now. An excellent point.

It seems to me that the BigBark code would allow us something very strong and stable immediately. Something with which we can have blogs indexed and added, and have people hitting the site to generate traffic. Of course, if we could have such an architecture built in a couple days, we could ignore BigBark, but that is rarely, if ever, the case.

So, my thought: Have these enthusiastic Java programmers spend the few days getting BigBark cleaned up immediately. Then, spend the time to design something fantastic. We may even have enough programmers joining that Craig can lead a team in parallel on design.

What’s your opinion?

Quick update

Thought a quick update on status would be good.

There are at least 4 people looking at the codebase, including me. This is a good sign because, although it’s complex and feature rich, it’s relatively clean and Patrick (@plightbo) has graciously provided a script to grab the dependencies, meaning going from “broken” to “not broken” is relatively painless.

Having awakened at 4:45 this morning (don’t ask), I was able to compile the codebase cleanly using his script (For the non-tech folks, this means that the engine runs, although there may be a few problems yet with brakes and steering, so you wouldn’t want your daughter to drive it yet).

I’m communicating with Patrick now about setting the code up on a server. Once that’s done, we will take AJ’s (@linuxaid) database and start connecting it.

Sam Klein stepped up to work on graphics, so when things are running, we’ll have a full graphics design, making a later search for such work unneeded. Thanks, Sam.

Right now the steps we need immediately to get the site running are:

  • Get the compiled codebase running on a test server.
  • Dump AJ’s database to the server and hook up the wires
  • Hook up AJ’s parser scripts to those wires to keep things updated

I’ll keep you updated here on how that’s going. Feel free to comment or send questions to the Google Groups List if you have them.

The Camel In Our Midst

Gil Taylor pointed out in his email to the Google Groups list that the current effort with ORBlogs is not working (rather than try to summize it, I suggest you read it because I may not judge it fairly).

I also suggest you read my reply just so that you don’t think I’m a thoughtful, intelligent person who calmly considers other people’s point of view before screaming at the top of his lungs.

In short, I’m embarrassed, and want to apologize. I’m sorry everyone. I’m sorry Gil.

There’s a large part of me that’s taken personal responsibility for trying to get ORBlogs back on the map. That responsibility- and subsequent accountability- is important for a successful effort. As I stated in my original post regarding ORBlogs- making one person responsible and accountable will give the community one single person to look to when they want to ask… well… just what Gil was asking:

Why the hell isn’t anything happening?

The one issue with being that person who takes on that accountability is that you have to both have the ability to get the job done, and have the skin thick enough to shrug stuff off. I suddenly wonder if I’ve been disingenuous in taking on this role.

Although there’s a part of me that wants to, I’m not going to give a list of things that we have accomplished, I think it’s fair enough to agree with Gil on where we are. ORBlogs is not yet live. Although I maintain my offense at the suggestion that we are a committee just meeting and not reaching consensus- I agree that the actual site is not running yet.

That’s been bothering me a great deal, and I was very happy when Kyle came forth with Ignoregon, because it seemed the best of both worlds. A functional, if basic, site for the immediate need- and another solid and active person to attack the BigBark code.

It seemed, in fact, like just what Gil was suggesting- and what we’ve all wanted.

So I think it was my earlier frustration with myself. It was anger, sadness and a great deal of pain at what’s happened personally. It was anger with my own lack of progress that I was reacting too. It wasn’t Gil’s comments about committees and camels which still sting just enough that I have to bring them up one more time even though it’s not a camel but a dead horse we’re talking about now (really, John, let it go!).

I was pretty forceful in my original post that we needed a point person, one person, to take responsibility. I didn’t actually think it would ever be ME (You’d never even heard of me before that!). I was stunningly honored that people would accept me, and suddenly felt that I had found a lot of friends. Still, we need to think seriously about this. My response to Gil was pretty irresponsible.

(By the way, that whole “friends” thing, oh and the italicized “active”- heck, half of this post- I can’t help it. We bloggers are writers first. I just can’t ignore those dramatic, touching bits. They shouldn’t sway you, however. Snap out of it.)

I’m sorry everyone. Seriously. I shouldn’t be speaking for ORBlogs, nor for AJ, Patrick, Rick or Kyle. If someone else wants to take over, I can turn over the domain, the blog, the Google groups account, the Goog-

(See- there I go, listing everything- even after I said I wouldn’t. Drama, I tell you.)

Okay, seriously. There are plenty of people out there better than me. Take over. Be someONE.

But you needn’t start from scratch. There’s that Java code just waiting. It’s right there- we’re pretty close.

By the way, Rick Turoczy has the keys to this house. AJ and Patrick have the keys to the code page. They- as anyone, should feel free to lock me out at any point.

Until then, I’ll just keep on chugging away, and realize that I owe Gil a beer for screaming at him. I really am sorry, Gil.

Oregon Blogs Aggregator Goes Live

Wow, you people move fast! I guess we should expect that if there’s a story to break, bloggers are going to be there before anyone!

Yes, Virginia, there is an Oregon Blogs aggregator. But it’s time for some pause before swamping the poor fellow’s server.

Backstory

Earlier today, I was emailed by Kyle Ritter of Barfly Magazine, who said that he’d taken Paul Bausch’s XML data and created a simple aggregator based on some other work he’d done. Then, after putting it up and registering a somewhat comical address (ignoregon, which I think is just hillarious) he decided to see if anyone else was doing anything.

Then, having discovered that there was indeed an effort to restore ORBlogs to even more than its original glory, he contacted me to ask about the status, and what steps he should take in order to not dillute or derail the current effort- if there truly was one.

All in all, it was a very thoughtful message, and I tried to reply in kind. Telling him that there was indeed an effort, that we had a functional and robust platform on which to build- and that we merely needed to get it on a server, work out a few bugs- and dump the database.

I discussed that, originally, our plan was to get something up immediately, and then design what we wanted- but that Patrick Lightbody’s code was basically everything we wanted anyway (categorization, Digg-style ranking, etc.) so the goal was to go live by October 1st (This was all something I was working on when a family death and some other home casualties derailed my deadline, by the way- I’m not ignoring you ORBlogs, honest!).

I then suggested that we talk ASAP. Mainly this was because I’ve been in a situation where I’ve done alot of work that was basically thrown out (that sucks, lemme tell ya) and wanted to personally recognize and thank him. But also- and more importantly- I thought that this could be a way to have something basic up and running that the blog community could use immediately, while we work on getting the more advanced code working- given my delay.

Frontstory

But, neither Kyle nor I recognized the blogger’s love of The Story (or at least the Blogger’s tendancy to… well… blog).

It seems that Jack Bogdanski came home and casually (not- as he notes- obsessively) checked his logs and noted the hit from Kyle’s aggregator and immediately wrote a blog post about it, setting off a flurry of activity.

So, now Kyle’s server is live with blog posts, but this is time for some pause for a couple reasons- not the least is that we don’t want to crush Kyle’s server

Kyle, did you know that Paul Bausch was seeing about 1300 page views per day? That’s one of the issues Louis and Clark was going to help us with. Hope you have bandwidth!

The Rest of The Story

So, the question is how do we proceed. My idea was that, assuming it can take both the traffic and the abuse, Kyle’s site be something Oregon Bloggers are immediately able to use, and we- still as quickly as possible- get Patrick’s code running. This will do a number of things:

  1. Give Oregon Bloggers something to use immediately.
  2. Give Kyle a name- since he is the man.
  3. Give the ORBlogs team an idea of load, desires, needs, etc. earlier than we’d otherwise have it.

Kyle’s happy to provide the bandwidth (assuming it’s not too much) and supports us using Ignoregon until the new code is bug free and live.

What do you think bloggers? Leave your comments here or head over to the Google Groups page for input. Until then, check out Ignoregon, and send Kyle a message- without knowing anything was going on, he got a basic site up and running. One more great person working for the benefit of ORBlogs.

Thanks Kyle!