From the product description
Word Jumble is a great and addictive game that will keep you coming back for more! Unscramble the jumbled words to reveal the secret keyword at the bottom. Over 5200+ possible words! Play against the clock or at your leisure. Think its too easy? You have 3 different times to test yourself against. Not sure what a word is? Use the hint feature to give you a hand. High scores for both Timed and Normal games!
Please feel free to leave some feedback, good or bad.
Thanks!
]]>Well that didnt take too long. I would like to do a few more updates (difficulty level settings, global high scores, etc) so hopefully that wont take too long to get those updates out the door. If you experience any problems with it, please email me at marcel@codeofdoom.com
Thanks!
]]>I would like to add difficulty levels to the game in the future, as well as a ‘continue’ feature.
I will keep you posted once the app is approved or not.
Cya then!
]]>The reason I haven’t is that I decided to get my mind off of it by making another Pre game. This one is much more recognizable, which is Simon. Yep, that game that you played with you were like 8, with the 4 buttons and you have to repeat the pattern. Anyways, it is in version 0.5.04 at the moment. I still have some things to work on it though. The pre does not seem to handle audio very well though. Almost as if it is a delicate flower.
Anyways, if you want to check out the updated game and simon, here you go!
Simon v0.5.04
Five or More v.0.7.25
Also, I do plan on doing some WebOs tutorials in a bit, so stay turned!
]]>I also fixed an ‘undo exploit’ where you could keep undoing and waiting for the right piece to drop in the right spot.
Anyways, feel free get the updated version
]]>http://predev.wikidot.com/installing-apps-on-a-stock-pre-post-1-04-update
And here is the game:
http://www.codeofdoom.com/fiveormore/com.codeofdoom.app.fiveormore_0.5.0_all.ipk
Some screen shots:
Screenshot 1
Screenshot 2
Screenshot 3
Screenshot 4
Screenshot 5
Things on the todo list:
- fix bug that doesnt let you move a piece to a certain spot
- Sound (sound from moving. maybe ambient music while playing?
- Add a background
- Add “special pieces”
- Add achievements
- Change the scoring around a little bit
Of course, if anyone wants to give any feed back on the gameplay, let me know. I also already want to rewrite this app. This definitely started with something where I was learning javascript, but definitely not applying best practices. Soon I will be picking up a few books to help out with that. I do have a few other ideas for games to create, so keep an eye out 
.
ps
Although I am sure many of you have heard, Palm made the SDK publicly available. So feel free to check it out.
This basically boiled down to those who were in charge of pulling the data down were not aware that what the client was asking was either a)something different or b) next to impossible given the dataset. No one knew it at the time, so everyone just found out as the project progressed. Luckily the blame of that was not on our plate, but it did affect our ability to get the job done in a sane manner. However, the project is “done”, so hopefully my schedule will go back to something more reasonable and I will be able to contribute more.
In the mean time, I did end up picking up a palm pre and actually got invited into their pre SDK development program. I have been messing with that and I have started working on a game called 5 or more. The gray pieces are “open spots” where you can move the colored pieces to. You have to have a clear path of open pieces when you move a piece from one place to another. Each time you move a piece, 3 more pieces will drop. Once you line up 5 or more of the same color, they will change into open (gray) pieces. Here are some pics of it so far:
5 or more picture 1
5 or more picture 2
Its pretty close to being completed. Once it is completed, I will be submitting it to the app catalog, so hopefully I will be able to be part of the initial wave of new apps .
In the future, I would like to start posting articles about developing for the pre, but I would like to get some more experience with it first.
]]>There are, of course, quite a few different interfaces. I have looked through them and picked out five interfaces that I consider to be the more important ones. For each, I will give a brief explanation of why they are important and where you would normally use them.
IListItemRenderer
Usually when creating composite components or item renderers, I try to stick with UIComponent rather than something like an HBox or Canvas. If you are going to use it item renderer for something like a list though, you are going to have to implement IListItemRenderer to your UIComponent. Keep in mind, if you dont use an UIComponent, there are a lot of other interfaces you will have to implement. If you want to keep it simple, use UIComponent.
When you implement IListItemRenderer, you are given access to the listData, which has one extremely useful property on it. Using the listData property, you will be able to tell in your item renderer which field of your dataprovider you are currently using. This property is know as the labelField. This is useful when you need to handle special cases for different properties. Since you have a access to this, you can setup something like a property map to handle each case.
When implementing the IListItemRenderer, when setting your getter/setter for your listData, keep in mind that the data coming in will be of type BaseListData. Be sure that your classes implementing this will have that property on it.
IDropInListItemRenderer
As you might have noticed, I did say to use the IListItemRenderer for lists. Well what about grids? With a IDropInListItemRenderer, you are able to reuse the renderer to assign it to multiple properties, for say, columns in a datagrid. Keep in mind that when using the IDropInListItemRenderer, you must also implement IDataRenderer(which I will discuss shortly). This is in order to have access to the data property. The listData is then used to initialize the data property. Normally when your components need to apply new listData, it takes place in the commitProperties (or in invalidateProperties is flagged. However you feel like describing it). When you implement your getter for listData, make sure you bind a dataChange event in your component like this:
[Bindable("dataChange")] public function get listData():BaseListData{ return _listData; }
This will ensure that your getters/setters are called properly. This also applies to IListItemRenderer. You will also notice that the BaseListData object is also used whenever you are using IDropInListItemRenderer. This is because the type that is actually used is dependant on the component that it is being used with. If it is a grid, it will use DataGridListData, Lists will use ListData and a Tree control will use TreeListData.
IDataRenderer
The IDataRenderer is another popular one amongst item renderers. This is what gives you access to the data property. Along with needing to work with the listDataRenderers, it is also used whenever a chart needs a renderer. It could also be used with datagrids as well, but for this, the data property would be the data for the entire row, not specifically for the item. Just like in our IDropInListItemRenderer, we need to make sure that our component has a binding for the dataChange event. The other important fact for this is that when you are setting your data, to fully complete the binding, an event dataChange event must be fired.
public function set data(value:Object):void { _data = value; dispatchEvent(new FlexEvent(FlexEvent.DATA_CHANGE)); }
IEventDispatcher
This is one of the more interesting interfaces. Not so much because its cool or does anything special, but it is the only interface where it is recommended to either:
a) extend EventDispatcher
or
b) if that’s not an option, have an IEventDispatcher property on your component.
Personally, I pick option B. If you have a property for it, it does give you the ability to assign a different implementation class to it, making it more versatile. You could leave it as a normal EventDispatcher, but you could also assign a CairngormEventDispatcher to it. Once you do this, you will be able to create your own hooks in order to dispatch your events.
IResponder
I feel this gets overlooked but it is definitely important in the world of data services. The reason it gets overlooked is that we just often copy/paste code like this and take it for granted that there will always be a result function for our service calls. However, this is the interface that gives us access to our result and fault functions that our asynchronous service calls make. Most of the time, we use existing frameworks such as cairngorm or puremvc for this, but it is good to have an idea of what is going on the background.
Usually our fault function looks like this:
public function fault(info:Object):void);
Normally a FaultEvent is what is returned, but according to the Flex documents, this is not always the face, hence it being returned as an object.
public function result(data:Object):void);
Once again, this normally comes back as a ResultEvent, but this is not always the case.
These are just a few of the major interfaces that I have used more often than not. There are quite a bit more. While knowing all of them by heart is not something I would consider necessary, but when you start creating custom components, knowing these interfaces and how to use them are extremely important. It allows you to create more flexible, clean and light weight components.
Think I left something out? Any other important ones? Wrong about something? Feel free to comment!
]]>I ask this normally because it is kind of a gray area. Well maybe gray area isn’t the correct phrase, but they are strikingly similar*. They both encapsulate and delegate the behavior of the classes. They both encourage composition. Both are great alternatives to inheritance. And they both allow for new behaviors to be easily added to existing classes. With all the similarities, its hard to see where they differ, making it a great question to ask in an interview.
Before I get into the details, I would like to have a quick explanation of what they are. Well I am going to cheat for the strategy pattern because it was one of the first articles I wrote. Go take a read…
.
.
.
If you didn’t read the article, the run down allows you to swap out implementations of what specific components can do at run time via the use of interfaces. Also if you really didn’t read it, go read it.
.
.
.
Alright, as for the decorator pattern. It is extremely similar except for the fact that it not just allows you to swap out implementation at run time, but they allow you to build ON TOP of the behavior of your components. The way it works is a base class with a specific behavior. Then our decorator will be a class that we will use to change that behavior by extending the base class, as well as having that base class as a property on the component. In essence, the decorator extends and wraps the base class. Lets look at a short example of how a decorator works
For this example, lets think of a text formatter. We want something that will take a string and format it however which was we want. There will be a decorator will make a String all capitalized, another that will concatenate two strings, then another one that will replace the word “this” with “that”. Here is our abstract class:
public abstract class Text{ public abstract String format(String s); }
And here is our base decorator:
public abstract class TextDecorator extends Text{ public abstract String format(String s); }
As you can see, our decorators are just extensions of our abstract class and they will have their own format function attached to it. Now lets take a look at our base implementations.
For our main class, it will just be something rather generic.
public class BaseText extends Text{ public BaseText(){ } public String format(String s){ return s; } }
This class will just return its text property with out any changes to it. Next lets see some decorators we could create in order to change our text.
public class AllCaps extends TextDecorator{ Text text; public AllCaps(Text text){ this.text = text; } public String format(String s){ return text.format(s).toUpperCase(); } }
public class StringConcat extends TextDecorator{ Text text; public StringConcat(Text text){ this.text = text; } public String format(String s){ return text.format(s).concat(s); } }
public class ReplaceThisWithThat extends TextDecorator{ Text text; public ReplaceThisWithThat(Text text){ this.text = text; } public String format(String s){ return text.format(s).replaceAll("this","that"); } }
Alright so now we have our three decorators. Obviously there is very little real world value to these, but this is just for example sake. The magic is really in the format function. Each one of the decorators takes in a Text object with its constructor. The format function then calls its format function to get its text, then decorators it based off whatever that format function does. But how does this all tie together in the implementation class?
public class TextImpl{ public static void main(String args[]){ Text t = new BaseText(); Text t1 = new AllCaps(t); t1 = new StringConcat(t1); t1 = new ReplaceThisWithThat(t1); System.out.println(t1.format("this is some random text")); } }
If you were to run this, you would get this output:
THIS IS SOME RANDOM TEXTthat is some random text
So what has happened? After we instantiated our base class, we then wrapped it, or “decorated” (funny how that works out) it, with our decorators. Then after we call the format function on this, it will before going through its decorators. In each format decorator, it will call its Text object’s format function, until it reaches an end. As it goes through, each decorator will perform its on specific task an then move onto the next.
That is how the decorator classes work. While it answers that question, it does not answer the question of ‘what is the difference between a decorator pattern and a strategy pattern?’ Well you might have been able to notice by now, but when you want to use a decorator, its usually a situation where you are going to have multiple attributes to an object that may or may not be used.
An example would be say something like a grid cell renderer. What if you wanted it your item renderers to make something bold. Another one would change color. Another would add a button to click. Another one would format a number, etc, etc, etc. You are either going to create one massive item renderer that you will have to maintain or create a class for each permutation of options, which adds up pretty quickly. With the decorator pattern, we can just create a decorator for each one of those and just wrap our item renderer.
Another good example is the dynamic filter component that was created in this article. A coworker of mine did an implementation of it using the decorator pattern. A situation like a filter component is perfect. We might need to filter on a date, a text input, etc. We can wrap our filtering work in multiple decorators to just go through it all.
Whats a good example of when to use a strategy pattern? The example I like to use is a logging system that you can change out which loggers are used at run time. Something like a strategy pattern works great here, because we don’t want to wrap something like this. There is no need to. This is a base implementation that is going to be used straight up. We aren’t going to add anything special to it. In this case, we have X amount of logger implementation (strategies), and when we want to change them, we do.
At this point, it boils down to when you want to use a multiple approaches to something, use a strategy pattern. When you want to create something where certain things may or may not be used to alter an object/component/whatever, then you should be using a decorator.
It can be confusing at times to tell the difference between them and when you would use one over the other. There are a lot of similarities that they share. Technically speaking, a lot of times, they can have the same out come. The choice of which to use obviously depends on your applications requirements. However, despite their similarities, they both still have their own specific place where they should be used.
Agree? Disagree? Think I left anything out? Feel free to comment.
If you want to check out the source, here you go!
*Note: There is also the state pattern, which is also strikingly similar. In fact, it pretty much does the same thing, but assigns them based on the state of your program.
]]>Turns out, the API is actually just a series of webservice calls that just return a json or atom string, so it is extremely easy to use (and it explains the mass amount of twitter programs out there). I don’t feel it would be too beneficial to create a bunch of ‘This is how you search for people’, ‘This is how you do a post’, so I decided to turn this into a mashup between this and google maps.
What I decided to do an article on is how to take twitters geocoded search feature and place them on a map within google. This article will explain how to call Twitters search service, parse that and then using Googles Geocoder, plot where those users are twittering from.
To make life easier, here is what our end result will look like.
Check out the demo here.
There are a number of things going on here. We are calling/parsing the twitter service/results. We are using Google Maps geocoder to decode the results location to give us a latitude and longtitude. We are then plotting those on the map. Once we do that, we then call up the twitter post when we click on the marker and display the content in a custom information window.
Before any coding goes on, read the section in this article on how to setup your environment for google maps(its the 2nd paragraph). Once you have that setup, you are ready. Since the Twitter API is just a series of webservice calls, you don’t need to download anything to use it.
To add the map to Google Maps, as you might have seen in previous tutorials, first you add it in your mxml:
<maps:Map xmlns:maps="com.google.maps.*" id="map" mapevent_mapready="onMapReady(event)" width="100%" height="100%" key="{GoogleConstants.KEY}"/>
The put this in your onMapReady function, initialize everything here:
public function onMapReady(event:MapEvent):void { geocoder = new ClientGeocoder(); geocoder.addEventListener(GeocodingEvent.GEOCODING_SUCCESS, geocoder_geocodingSuccess); geocoder.addEventListener(GeocodingEvent.GEOCODING_FAILURE, geocoder_geocodingFailure); map.addEventListener(MapMouseEvent.CLICK,mapClicked); centerPoint = new LatLng(40.714036986015984,-74.00337009008788); map.setCenter(centerPoint, 14, MapType.NORMAL_MAP_TYPE); var poly:Polygon = MapUtils.drawCircle(40.714036986015984,-74.00337009008788, 1.0, 0x000080, 1, 0.75, 0x0000FF,.5); map.addOverlay(poly); }
I decided to drop the default lat/lng over Manhattan (popular enough place to find tweets). The event listeners added for the geocoder is going to be used for when we try to get a location from our twitter posts. We also add an event listen for our map to listen for mouse clicks (to set a new location). After that, I draw the circle around the center point. I “borrowed” the code to draw the circle from another example. No need to reinvent the wheel.
Now you are going to notice that there really isnt too much to using twitters API. First you setup a httservice within your mxml:
<mx:HTTPService id="twitterService" resultFormat="text" result="parseResults(event)" fault="fault(event)" showBusyCursor="true" />
To make the service call, we hook it into a button to trigger that, which looks like this:
public function getGeoCodes(event:MouseEvent):void{ var s:String=""; if (username.length >0) s="&q=from%3A"+username.text; twitterService.url = "http://search.twitter.com/search.atom?geocode="+centerPoint.lat()+"%2C"+centerPoint.lng()+"%2C"+stepper.value+"mi"+s; geocodesButton.enabled=false; geoAlert.visible=true; setTimeout(disableGeoCodeButton, 10000); twitterService.send(); }
As you saw in the picture, we are able to search by both a radius from a center point (the circle drawn on the map) and optionally by a username. All we do here is call the service using atom and passing the latitude and longitude, along with a user name to it. This event listener is what is attached to the Get Geocodes button. After that, it goes to the parseResults listener.
public function parseResults(event:ResultEvent):void{ var rawData:String = String( event.result ); var arr:XMLDocument= new XMLDocument(rawData); var decoder:SimpleXMLDecoder = new SimpleXMLDecoder(); var data:Object = decoder.decodeXML(arr); var array:Array = []; if (data.feed){ var array = ArrayUtil.toArray(data.feed.entry); for each (var o:Object in array){ markerManager.addTwit(o); geocoder.geocode(o["location"]); } } }
Once it comes back we parse out our results. The entire twitter object comes back within the returned XML. First we save that tweet in an object I call MarkerManager (maybe should be called TwitterMarkerManager?). After that, we then use Googles Geocoder to find a location to plot for the location given within the specific tweet.
public function geocoder_geocodingSuccess(e:GeocodingEvent):void{ var point:LatLng = e.response.placemarks[0].point as LatLng; var nm:NamedMarker = new NamedMarker(e.response.name,point); addMarker(nm,point); } public function addMarker(nm:NamedMarker,point:LatLng):void{ var marker:Marker = new Marker(point); markerManager.addMarkerName(nm); marker.addEventListener(MapMouseEvent.CLICK,getTwit); map.addOverlay(marker); }
A Marker is an object within the Google Maps API. It is an object that is placed on the maps and gives us (by default) that nice red looking pin on the map. Unfortuantely, it doesnt have a name property for me to ues on this, so I just extended Marker and added the property, giving us NamedMarker. The event.response.placemarkers (which seems to always turn an array of length 1??) is where the result of what googles says the latitude/longitude your location mapped to. We then add the NamedMarker with the event listener for retrieve the tweet associated with it to the MarkerMananger object. After that, we add the Marker to the map.
For the sake of clarity, lets also take a look at this ill-named MarkerManager:
public class MarkerManager{ private var _markers:ArrayCollection private var _tweets:ArrayCollection; public function MarkerManager(){ _tweets = new ArrayCollection(); _markers = new ArrayCollection(); } public function addMarkerName(nm:NamedMarker):void{ _markers.addItem(nm); } public function getTwitByLatLng(latlng:LatLng):ArrayCollection{ var arr:ArrayCollection = new ArrayCollection(); for each (var nm:NamedMarker in _markers){ if ((nm.getLatLng().lat() - latlng.lat() == 0 && nm.getLatLng().lng() - latlng.lng() == 0)){ var s:String = nm.name; arr= getTwit(s); } } return arr; } public function cleanMarkerInfo():void{ _markers=new ArrayCollection(); _tweets = new ArrayCollection(); } public function addTwit(twit:Object):void{ _tweets.addItem(twit); } public function getTwit(name:String):ArrayCollection{ var arr:ArrayCollection = new ArrayCollection(); for each (var t:Object in _tweets){ if (t.location == name) arr.addItem(t); } return arr; } }
It’s a pretty straight forward utility class. It just holds the markers and tweets and then retrieves them.
At this point, you are able to retrieve tweets, add them to your map and mark them with a Marker object. Now we want to view them. We need to create a customer object in order to display the information we want. Before we look at that, this is the event that handles a click on a marker
public function getTwit(event:MapMouseEvent):void{ var arr:ArrayCollection = markerManager.getTwitByLatLng(event.latLng); var tc:TwitterControl = new TwitterControl(); var marker:Marker = event.target as Marker; tc.setTweets(arr); marker.openInfoWindow(new InfoWindowOptions({customContent:tc,width:400,height:200,drawDefaultFrame:true})); }
First we get any tweets with that latitude an longitude associated with that marker we just clicked. Within the manager, it first checks the lat/lng against all the saved NamedMarkers. If it finds a match, it will go grab the tweet with that name then return it. It then sets the property to the TwitterControl, which is the custom InfoWindow object.
<?xml version="1.0" encoding="utf-8"?> <mx:VBox xmlns:mx="http://www.adobe.com/2006/mxml" width="400" height="200" > <mx:Script> <![CDATA[ import mx.collections.ArrayCollection; import com.google.maps.overlays.Marker; import mx.controls.Text; public var currentTweet:Object; public var tweets:ArrayCollection; [Bindable]public var totalText:String; [Bindable]private var _content:String; [Bindable]private var _author:String; [Bindable]private var _time:String; private function setTweet(index:int):void{ var tweet:Object = tweets.getItemAt(index); if (tweet){ currentTweet = tweet; _author= tweet.author.name; _content = tweet.title; } } public function nextClick(e:MouseEvent):void{ var i:int = tweets.getItemIndex(currentTweet); if (i+1 < tweets.length) setTweet(i+1); } public function prevClick(e:MouseEvent):void{ var i:int = tweets.getItemIndex(currentTweet); if (i-1 >=0) setTweet(i-1); } public function setTweets(arr:ArrayCollection):void{ tweets = arr; totalText = "Total tweets : " +tweets.length.toString(); setTweet(0); } ]]> </mx:Script> <mx:Text id="total" text="{totalText}" /> <mx:TextArea editable="false" wordWrap="true" width="100%" text="{_author}" id="author"/> <mx:TextArea editable="false" wordWrap="true" height="50" text="{_content}" width="100%" id="content"/> <mx:HBox> <mx:Button click="prevClick(event)" label="Prev"/> <mx:Button click="nextClick(event)" label="Next"/> </mx:HBox> </mx:VBox>
Nothing really special about this. Just a few display options and controls. This is what will go through the arrayCollection of tweets though and display the author and content of that tweet.
Here is one thing to note. When you do a search, you are given the last 15 posts in that area. You might notice though, you are only getting about 4 markers? Well if you look back at the beginning, we added a listener on the geocoder for failure. Why is it that on the picture I provided has around 8 to 10 of them? After looking what was failing, I noticed some of them were things that didnt make sense (IE: LIVIN IT UPTWN IN QUEENZZZZ) and as awesome as google is, that is not being mapped to an address.
What is more important, I did notice something else was failing to map to an address, which was posts from iPhones. Another interesting note, when locations come back, normally it would be something like “Brooklyn”, “NYC”, “Queens”, “Astoria”, etc, which were mapped to generic locations, not exact location of the tweet. BUT, a post from an iPhone gives their latitude and longitude (which I am assuming is at the time of the tweet). Now that is awesome/creepy! So how do we parse those?
Here is what the geocoder failure event looks like:
public function geocoder_geocodingFailure(e:GeocodingEvent):void{ if (e.name.indexOf("iPhone") > -1){ //iphone found var point:LatLng = MapUtils.cleanIphone(e.name); var nm:NamedMarker = new NamedMarker("iPhone", point); addMarker(nm,point); } }
We scan the name (which is the location property on the tweet) for the word “iPhone” and if we have a match, we then get the lat/lng from it and add it to our marker list. We still have to change a few other things . In our addTwit function in the manager, change it to this:
public function addTwit(twit:Object):void{ if ((twit.location as String).indexOf("iPhone") > -1){ //handle iphone var latlng:LatLng = MapUtils.cleanIphone(twit.location); twit.location = "iPhone: "+latlng.lat()+","+latlng.lng(); } _tweets.addItem(twit); }
then change getTwitByLatLng to this:
public function getTwitByLatLng(latlng:LatLng):ArrayCollection{ var arr:ArrayCollection = new ArrayCollection(); for each (var nm:NamedMarker in _markers){ if ((nm.getLatLng().lat() - latlng.lat() == 0 && nm.getLatLng().lng() - latlng.lng() == 0)){ var s:String = nm.name; if (s.indexOf("iPhone") > -1){ s = nm.name+": " + latlng.lat()+","+latlng.lng(); } arr= getTwit(s); } } return arr; }
Now when you run this, especially in dense areas of Manhattan, we will see a bunch more pop up, all with the ever so interesting and informative twitter posts that everyone is dying to read! Side note, I did notice another location failing that also gave its lat/lng, but I felt for the sake of the tutorial, I did not want to cover it with parsers. Feel free to add it in the source yourself though.
Here are some other things to keep in mind. One, not that I think I have to worry about it, but the Google Maps API allows 15,000 geocode searches in a 24 hour period. If you really want to play with it, I would recommend you download the source/swf yourself and play around with it. As for the twitter API, they limit you on searches as well (hence me putting a 10 second timer on the button). What is more annoying, they tell you that you get 100 searches or something like that an hour. Unfortunately, they do not tell you how many geocode searches you get. They just say it is different. Long story short, depending on how popular this article gets, it might break it for the day hehe.
On top of that, I tried testing it out on myself and failed. I put up a new twitter account, made sure my location was set, and placed a tweet up there. I was let down when I could not find myself. Then after examining the twitter post through their own search API by username, I noticed my location was not set on the posts, explaining why I could not find myself. Feel free to try it out with an iPhone though.
If you did not notice, I opted to use .atom results over json results. I would have preferred to use json, but I could not get the json to parse correctly using the built in json parser in actionscript3 corelib. Not sure why, but when I used atom, everything was fine. Lastly, the only reason I added the username portion is if someone is using an iPhone, the results are even better, as you get to see where they actually were. Some results I got from an iPhone user would always point to the same location (shrug?), but a few of them mapped out their day on the map.
I feel Twitter did a really good job at making it simplistic to utilize their services. It really cannot get that much easier than just calling a webservice with some query results. It does expalin the extremely large amount of Twitter applications out there. This project somewhat ballooned out of control with the amount of things I wanted to do with it, especially considering I just wanted this to be a post on using the Twitter API. There are many other functions with the Twitter API that can be used (posting, searching, etc) that is worth checking out.
Questions? Concerns? Feel free to comment!
Check out the source here.
Check out the demo here. Please heed the warning I gave before on possibly crashing it though. Once again, if you really want to play with it, I recommend just downloading the source and running it on your machine. Thanks!
]]>