Whoahbot!

6502, assembly and you. Part 3

2011-08-20T00:00:00-07:00

6502, assembly and you. Part 3

Before I begin, let me say that while programming for the 6502, one must surely consider the following musical choices
to be at a premium: Studio One Scorcher, or at the
very least: Budos Band II.

At any rate! If you have been following along, you surely have guessed that the missing instruction from the quiz in part 2 is of course TXA!

Once, again, our cast of characters:

The Sim, The Book, The Reference

And on to the plot. This is act 3, the climax and then the dénouement!

Processor status register!

On our happy little substrate of silica, we have the following flags that are stored in the processor status register:

bit   7                           0
    +---+---+---+---+---+---+---+---+
    | N | V |   | B | D | I | Z | C |
    +---+---+---+---+---+---+---+---+

Instructions to the processor can set these flags after an instruction to indicate things like whether the result of the last instruction (dec, inc, load) was zero. These all have their use, but we will set careful study for the moment upon the Z flag.

By the by, if you haven’t read Zero: The Biography of a Dangerous Idea, you most certainly would enjoy it… By the by and by, if I lent you my copy of that book, could you please return it?

Avast! Processor status flags, like our friend Zero are quite handy for control flow, as in the following example:

LDA #01
LDX #05
jump:
STA $01FF,x
DEX
BNE jump

Pray, notice carefully that we are no longer jumping forever! There is a new sherrif in town and her name is BNE. Also note carefully the section of the reference that speaks volumes of the DEX instruction:

DEX  Decrement Index X by One

     X - 1 -> X                       N Z C I D V
                                      + + - - - -

     addressing    assembler    opc  bytes  cyles
     --------------------------------------------
     implied       DEC           CA    1     2

The two plusses there indicate that this instruction can set the N or Z flags in the processor status register, in this case, decrementing X during the last run will set the Z flag of the processor status register, and the BNE instruction checks to see if that flag is set before jumping back into he subroutine.

Gifted with this new information, the careful bit manipulation of the skilled assembly alchemist becomes clear, and much more interesting operations present themselves.

Do be careful when cooking with this recipe! Never forget that unless you are wary, another operation may have set that processor status flag much earlier in your program, and it may not be safe to use unless cleared beforehand.

Thank you, dear reader. I bid you the fondest of farewells for now. I may continue with this series, if my mad education in this realm continues, but I shall always keep fond memories of our times together and the bits we flipped.

6502, assembly and you. Part 2

2011-08-13T00:00:00-07:00

Now, you’ve heard the soulful sounds of part one, this is part two. Are you ready?

Introducing the players:

The Sim, The Book, The Reference

The Sim is a wonder in itself, you’ll want that open in another tab while you read on, dear friends. If you want to be taken back to the heady days of 8-bit gaming, load up “Adventure” from the examples menu. (Use WSAD to move).

In our happy little 8 bit wonder, we have several things to keep track of.

There are a total of three general use registers:

The Accumulator handles all arithmetic and logic.
X and Y are general purpose registers that hold one byte (8 bits) of data. By the by, this is a joke that should be on the inside of
a laffy taffy wrapper:

Q: What do you call one half of a byte?
A: A Nibble

I’m sorry, our friend mentioned in part one had used the word ‘nibble’ so many times that it wasn’t funny to him anymore, but it made me laugh. Onward!

You can load X and Y, and A with a value directly:

LDA #02 ; Loads the value 2 into the accumulator
LDX #00 ; Loads the value 0 into register X

Now then, we have two values that are loaded, one that we can use as a color (2 is red in this sim), we’d like to store that color in a memory address. We do so, like so:

STA $0200 // Store the value of the accumulator in memory address $0200

Compile that, and run it, and you should have a little red ‘pixel’ on the right. Keep in mind that this simulator is visually showing you the contents of memory as a color in that block.

STA can also take a register as an offset, thusly:

STA $0200,x ; Store the value of the accumulator in memory address $0200 plus an offset of the value in the X register.

Yes, yes, all very useful, but we need a looping construct! Enter JMP.

LDA #02
LDX #00
paint: ; Make a new subroutine called 'paint'
STA $0200,x
INX
JMP paint ; jump back to the subroutine called 'paint'

This happy little 6502 program will continue to paint the town red. See how proudly it paints? Jump Forever!

Red is nice, but there is a way to make the program paint pretty stripes instead using only one new instruction. See if you can figure out how. You’ll need just one other instruction we haven’t used before in your paint subroutine. Here is the reference again for your perusing pleasure.

Part 3 will cover processor flags, and what amazing possibilities await you armed with those tools!

6502, assembly and you. Part 1

2011-08-12T00:00:00-07:00

6502, assembly and you. Part 1

Greetings Program!

A friend of mine is quite the computer historian, spinning grand tales
of old silicon, and the heady days of computing in the 1970’s. I
should more properly introduce him as a caretaker of knowledge. It’s
difficult to speak to him on any subject and not have him surprise you
with something you didn’t know on the matter.

At any rate, on his most recent visit to my place of employ, he had a
mischevious grin on his face when he arrived. When probed further on
the source of the twinkling in his eye, he said that he had decided it
was time for us to learn assembly!

“Not just any assembly, either.” He continued, “This is 1970’s
stuff, 8 bit processing with the 6502.”

Surely you recognize the 6502? No? Neither did I. My archival friend
did enlighten us:

At the time, the 6800 was the top dog of the day, but it’s pricetag of $300
made it the purvey of kings and large companies.

An intrepid lad named Chuck Peddle did try to Peddle the 6800 to
gentlefolk of lesser means, but their rejoinder was always the
same. They would love such a processor, but only at a much more modest price.

Peddle began to design such a substrate of silica, and
brought his idea to the management team at Motorola. They laughed into
their cognac at his suggestion that they should make a processor,
since their flagship product had unfurled their flag so well.

On to MOS flew most of the design team at Motorola, en masse! Where
they completed work on the 6501, a totally new design with a sultry price tag,
and pin-compatible with the 6800 to boot!

The management team at Motorola sputtered and spewed black clouds from
their havana cigars, and sued at once! And so, our modest friend the 6502
was made, and made “Lawsuit Compatible”.

From this chip sprung many new computers of which I’m sure you are
familiar with: the Apple ][, the NES, the Commodore VIC-20, the Commodore 64,
and your old friend, Atari 2600.

Click the chip to read more of this fascinating tale, and adieu for
now, but I will post more this weekend on the nature of programming
the 8-bit beast and all that I have learned from our friend.

Part two, are you ready?

In thirty days

2009-08-25T00:00:00-07:00

In thirty days

My Lords, Ladies and Gentlemen:

Birthing an idea is such a strange and wonderful process.

A while back, I was totally consumed over by something someone said in an interview. I can’t remember who it was that said it, although I thought it was one of the Github crew. (Please leave me a comment if you can find the source). The premise is that if you have an idea, you should put it away for thirty days. If you come back to your idea and thirty days and it’s still a great idea, you should do it.

I often times go through really slow periods of creativity where I feel uninspired to do anything. I hardly write any of my ideas down. I wanted to create something that would help me through these times when I’m uninspired. An idea, buried carefully in soft peat for a month to see if it will germinate.

I also love weekend projects, the whirling energetic emergent pattern of colors and code and ideas. Idea to finished product in days. It was also a really great way to play with the Twitter API. John Nunemaker’s twitter gem made Twitter and OAuth painless, once you conceptually understand how things work.

Also, if you haven’t checked out Heroku, you should. Heroku was instrumental in being able to develop and publish an idea in a weekend.

So the finished concept is this. You go to In Thirty Days and stash your idea. In thirty days, an automated whoah-bot will DM the idea back to you on Twitter.

Please drop me a line if you find it useful, or if you have some feedback at: whoahbot (at) gmail (dot) com

(((((Clojure))))))

2009-08-20T00:00:00-07:00

(((((Clojure))))))

Clojure is an accessible funcitonal programming language, with it’s paranthetical tendrils rooted in the jars of Java. It’s full of arcane goodness and (secrets (within secrets (within secrets))). Yes, indeed, a Lisp dialect is this.

It’s fun to peer through time to speak a vernacular first uttered in 1958, my own personal journey facilitated greatly by the most excellent screencast by the Topfunky hisself.

Within the endless enclosures of code as a data type, the astute reader will discover a powerful grammar for dealing with concurrency and the virtues of laziness. It infuses the mind with visions of infinite datasets resolving themselves into structures across powerful and massive architectures. Heady stuff in these days of computing lazily from the clouds.

Programming in clojure is fun, eschewing any notion of ‘Objects’, or ‘Classes’, or any such thing. Applying functions to functions to functions to functions to functions that return functions in fractal fashion. Looking to the novice as a mindless series of parentheses, but to the aspiring journeyman as the intricate jewel crafted movements of a watch.

DataMapper loves Redis

2009-05-27T00:00:00-07:00

DataMapper loves Redis

In some cultures, a diamond is the traditional gem of marriage. I hope that you will forgive me, dear readers that I sealed this union with rubies.

DataMapper and redis are hitched up! What a joyous event. The sweet strain of Identity Map we know as DataMapper found a beautiful partner in the sleek and speedy redis key-value database.

The adapter is now ready to show it’s love in public. Hitch it up to your app and ring wedding bells.

Hardcore forking and gemming action:

You can fork the project, or install the latest gem at GitHub, of course.

Before I get too terribly sloshed at the reception, do let me know if you find bugs.

Jackin up .js with jabber, nginx, jsjac and ejabberd

2009-04-20T00:00:00-07:00

Jackin up .js with jabber, nginx, jsjac and ejabberd

Dear, dear friends:

I wish to tell you of a great opportunity, yes yes! A simple way to have the users of your site jabber away at each other night and day. Lets introduce the players.

This is our hero, bobo wewo. Bobo would really like to get his users chatting on his site, just the usual chatter about the wewo community that happens around the water cooler at work, but Bobo is of a mind that there should be a web site where people can talk about wewo things. This is were we come in.

Ejabberd

Lucky for us, bobo already has a copy of Ejabberd running. Ejabberd is an excellent XMPP server written in erlang. Erlang is also excellent. All of this is excellent. But we need one more thing to glue this all together.

Ejabberd implements an extension to XMPP called “BOSH”. Bosh stands for “Bidirectional-streams Over Synchronous HTTP”, and if you want all the gory details, you can read yourself silly right here. Traditional ‘Ajax’ requests are asynchronous by definition, but in our case, we’re going to use jsjac to open an request that doesn’t close right away, or even send data right away.

To accomplish this magical feat, we tell bobo’s ejabberd server to enable the http_bind module.

Also double check to make sure that the http_bind module is being loaded when you start Ejabberd.

Proxying requests to the ejabberd server.

If you’ve read my other lewd exploits, you’ll recall fondly that we’ve spoken at length on the subject of browser security policies and how to trip lightly around their jackboots. To accomplish our wewo-talking, we’ll need to proxy requests to the ejabberd server using a webserver. Even though the servers are on the same box, they still need to be proxied because they are on different ports. Here are the config files to do this with apache or nginx.

JSJac

Oh yes, you’ll need JSJac. JSJac makes it very easy to manage connecting to a server, sending presence messages, and other message types. Speaking of which, why don’t we do just that?

Once you have jsjac installed in your page, it’s a simple matter to get it connected:

First, we create an object literal to house the settings for the connection, pull our username and password from the html form we’ll use, and create a JSJaCHttpBindingConnection. We also want to bind important events for the client to respond with, mainly messages, connection status and errors.

Next, we construct a presence message, bound for a multi-user-chat room called #wewo. Presence messages are love notes to the XMPP server that in this case, tell it that we wish to join our pea-shaped peers in the chatroom.

After doing so, our chatroom is ready to convey our messages to the rest of the wewo clan regarding last night’s episode of ‘fresh boss’. To send a message to the server, we once again leverage our friend jsjac to do so. We set our message recipient to #wewo@conference.example.com/whoahbot, which tells the chatroom that this is a message from whoahbot, to the chatroom. We set the body of the message, and lastly change the type of the message to ‘groupchat’.

Debugging

I found it most useful to use PSI when debugging, since you can easily see which xml stanzas are being exchanged by you and the server.

Fin

Lads lords and ladies, I do hope that is enough information about xmpp and jsjac to get you started, and enough information about wewo culture to last you a lifetime. Until next time,
Here is the skeleton of the app we’ve been working on. Bobo still hasn’t paid, so I didn’t style it.

If you are going to use xmpp, might I make you highly suggestible with some sodium pentathol and SUGGEST that you purchase the most excellent screencast on the topic by the topfunky himself: XMPP/Jabber with Ruby. Topfunky is so cool, he chose pink and black for his site and I’m ever so jealous.

DataMapper and Redis

2009-02-19T00:00:00-08:00

DataMapper and Redis

Listen:

When we last left our hero, he was slinging silly coffees with someone named jason. This week, dear friends, the shiniest bauble to have caught the Whoahbot’s eye happens to be a chrome-plated, espresso powered monster called Redis

About Redis

Redis is a key-value database. It is similar to memcached but the dataset is not volatile, and values can be strings, exactly like in memcached, but also lists and sets with atomic operations to push/pop elements.

This is the description on the home page, and you may be thinking: “Crumbs, I really have to go… I just saw a bit of paint drying in my kitchen that I must attend to”. But oh let me tell you, this is the ferrari of key-value databases:

====== GET ======
  10000 requests completed in 0.26 seconds
  50 parallel clients
  38759.69 requests per second

====== SET ======
  10004 requests completed in 0.24 seconds
  50 parallel clients
  41000.00 requests per second

I highly suggest that you dig out your rubies and try the excellent libraries offered by Ezra at Github, or try the Gelato of DataMapper adapters.

JSONP web services with rack

2009-02-11T00:00:00-08:00

JSONP web services with rack

Our story begins

Listen:

In our last gripping episode, we followed the grim tale of a cupcake and his deadly [coffee] messages.

These secret susurruses were fetched from a Rack app that can serve both JSON, and return a properly formatted JSONP for javascript clients.

Enter the hero: Rack

Rack is one of those things that you don’t get at first, and then you get it, and then you were embarassed that you didn’t get it in the first place. Or was that just me?

A Rack compatible ‘app’ just needs a few things to get going.

Define a call method
Return an array with three items
The response code
The headers
Anything that responds to the each method. Say… a string, or a pack of “wild dogs”.each do |bite| “ouch” end
It should be nice and return the proper headers, Content-type and Content-length

Install rack the same way you install any gemified rubies.

sudo gem install rack

Lambdas are a simple call girl, lets make her an app right now! We’ll return text/html as our mime type now so you can check it in a browser.

use Rack::ContentLength

app = lambda { |env| [200, { 'Content-Type' => 'text/html' }, "Hey there, sailor" ] }
run app

Put that little lady in a file called config.ru, and run ‘rackup ./config.ru’. You should be able to visit http://localhost:9292/ for a good time. What’s that ‘use’ statement for, you ask? Err… lets take a short break.

Intermission

Stumptowner

Your first rack app! As much as your first rails app ever returned with quite a bit less code. I was going to take a few more swings at rack jokes, the obvious ones just hanging there like rotten fruit, but I’m sure you’ll write an app to generate them for me anyway, so lets move on.

So, where we did put a string that salutes our fighting sailors, we could put nearly anything that responds to the each method. For the stumptowner app, we have a small, but quite silly string from the generator. The string that is returned is properly formatted JSON response.

Our poor sailor is on his own with lady lambda, so I’ve put my generator in it’s place.

app = lambda { |env| [200, { 'Content-Type' => 'application/json' }, Stumptowner.to_json ] }
run app

Great, fabulous, contragulations you graduate. Happy racking. Here’s your ruby shaped hat and diploma.

Wait, stop! Come back, cease and desist! This won’t do. Whoahbot, you’re fired. See d. trump for your haircut on the way out. This won’t work for javascript apps making cross-domain requests. We need a little p in our json for that.

Middleware

Yes yes, let us introduce you to rack middleware:

what’s great about rack
is that it will stack
on top of itself, hoo-ray!

Wierd, there’s no syntax highlighting for limerick. At any rate, middleware is the lego of web framework, it’s the layers in your cake, the stacks of waffles downstairs, complete with butter and maple syrups.

In our steamy ‘sailor come hither’ app above, we used the rack supplied Rack::ContentLength middleware to properly set the content-length header of our response. If you don’t do that, rack has a lint middleware that will wag it’s naughty finger at you. You can set the content-lengthby hand, or you could be lazy, the mark of any good programmer.

Saying ‘use Rack::Content::Length’ tells rack that before you return the finished response code, headers and body to the client, calculate the length of the response, and put that in the headers.

Just as there is a middleware for setting the content-length, the fabulous, handsome and prolific minds of the rack community have produced JSONP middleware as well.

The completed app sings the body electric like this:

require 'stumptowner.rb'
require 'jsonp.rb'

use Rack::JSONP
use Rack::ContentLength

app = lambda { |env| [200, { 'Content-Type' => 'application/json' }, Stumptowner.to_json ] }
run app

Tra-la! The beauty of this approach is that non JSONP clients just get regular JSON, while jQuery and his pals get what they need.

And they all lived happily ever after. The end.

JSONP, and the manchurian candidate

2009-02-08T00:00:00-08:00

JSONP, and the manchurian candidate

Got any coffee? No? Click [Coffee?] for the brew of the day.

Good. Now lean back, and let me tell you how you just put the manchurian candidate of cupcakes into your window object. (Don’t look now, he’s gone).

JSON is a fantastical data structure, coalesced into being by one of the few people on the planet that think that JavaScript is a wonderful and mellifluous language to write in. Well, maybe he only likes the Good Parts.

But until Crockford’s JSONRequest is widely implemented, what we have to work with for cross site mashups is the blackest of black arts. There are secret handshakes for you to grasp and grip. A mysterious contract hitter called JSONP, or JSON with ‘Padding’. I will tell all fingerings of the handshakes in time, but first, I want you to meet your browser window:

A cheerful fellow. Happy-go-lucky. Ties his shoes the same way every morning. But something lurks beneath his frosted grin. Yes, our friend here is highly suggestible, he buys the new car AND the undercoating. Poor fellow, we’ll imprint him with a secret phrase when we initiate a JSONP request.

I think our brothers in arms at jQuery said it best when they said:

// Handle JSONP-style loading
window[ jsonp ] = function(tmp){
	data = tmp;
	success();
	complete();
	// Garbage collect
	window[ jsonp ] = undefined;
	try{ delete window[ jsonp ]; } catch(e){}
	if ( head )
		head.removeChild( script );
};

Whoah! What was that that just whizzed by? Did our tasty friend get a new function planted in his cake? Yes! And when the secret word is mouthed at the dinner party he’s attending, he screams forth his JSON object literal! Layered cakes are not to be trusted.

When the ajax request went out, it looked like this: http://stumptowner.whoahbot.com/?callback=jsonp1236556779135. When it came back, it called the secret function ‘jsonp1236556779135’ thusly:

jsonp1236556779135({"coffee":"Pallat of Panama Manifested",
  "country":"Panama","elevation":"2935 - 3317 Meters",
  "varietal": "Chai and Chai",
  "flavors":"Fragrance of bacon, pie and mango delivering a silken mouth feel."
  })
};

In the snippet above, window[jsonp] is a function that takes one argument. That argument is the JSON data returned from the AJAX call.

What’s going on here? Why would someone do this? Why a cupcake for the love of confectioner’s sugar! The problem lies buried in cross-border passport restrictions for XMLHTTPRequests. Cross-domain ajax requests are forbidden by your browser’s same-origin policy and the internet gestapo.

This is most distressing for us that want to make hilarious JSON mashup datasources! And so, Bob Ippolito proposed an ad-hoc standard that neatly dances through checkpoint charlie.

For those that are about to JSONP, here is how we salute you:

$.getJSON("http://stumptowner.whoahbot.com/?callback=?", function(data) {
  $('.something').append("<div class='coffee'>" + data["coffee"] + "</div>").
  append("<div class='elevation'>" + data["elevation"] + "</div>").
  append("<div class='varietal'>" + data["varietal"] + "</div>").
  append("<div class='flavors'>" + data["flavors"] + "</div>")
});

Your friendly neighborhood jQuery.getJSON function, or it’s big brother $.ajax, will replace the callback=? in the url parameter with an automatically generated callback function name. Tra-la!

Next up, constructing iron-curtain subversive JSONP (P for propaganda) web-services using Rack!

whoahblog

2009-02-05T00:00:00-08:00

whoahblog

10.times do
  begin
    create_new_blog
  rescue Error::Frustration => e
    drink(gin)
  ensure
    drunk(@whoahbot)
  end
end