Dragon con Battlebots – Das Roomba

Started construction on the Mk2 Roomba for my 3lb entry into dragon con this year.

Started out with this heavy sucker, donated to me by a church. (They never knew they were sending their children off to war for sport, those poor mothers.)

IMG_2501

So, how do we do this? Lets walk through the rebirth of a Roomba.

The first thing we need to do is weight reduction. Out of the dog-hair infested box, where this poor robot must have lived as a slave cleaning dog hair from a Labrador Retriever farm, it weighed about 11lb. Which is 8lb too many! Our weight class only allows for 3lb of robot after all.

IMG_2498

The Unmodified Roomba bottom, with all its extra weightIMG_2499

We remove the unnessesary components for its new life. After all, what need is there for a vaccuum module in its new life as a combat robot.

In addition, remove the battery. It was fueled by a huge NiCd block, which was a substantial source of weight

IMG_2500

With just the bottom cover removed, we dropped down to 4.44lb. Quite substantial.

But we are not done yet. Our target goal is about 2lb.

Time to get out the saws and cut some parts off!

First up is the electronics bays

IMG_2502IMG_2503

As you can tell, they use some rather heavy circuit boards. Half a pound, which is a lot, especially considering that they aren’t really that old. Modern electronics for this application should be a lot lighter.

IMG_2504

The core frame (Just the plastics with the motors removed) is at almost a pound. Way too much when this is about 30% of the bot.IMG_2512

So lets move to the first weight reduction. That thick plastic that rests atop the cleaning components. Seeing as we do not have the cleaning bay anymore, we can remove heavy plastic on top.

IMG_2514

Clean that up, and we have some good losses

IMG_2518

And success, we have brought our framing weight to under 2lb.

IMG_2530

Next we work on the wheel pods

IMG_2532

For these, we need to remove the extra sensors to save a little weight, and put in some heavier gauge wire (24 gauge) to handle continued stall current. The motors draw 3Amp at 13v stalling, and due to the nature of our competition, I like to plan for the worst if I have weight to allow to it.

IMG_2537

We shaved down the ciruit board a little. (It has lots of not used conduits for the sensors we will not be wiring. Originally, there were 5 wires going into it. ) and solder in our speaker wire. We attach them directly to the pads used for the motor on the board.

IMG_2539

We then reinstall the wheels and insert a small 18gauge 6063 Al shield. This will help protect the wheel wells a little from damage by thickening up the walls with something a bit more sturdy.

IMG_2540 IMG_2541

This brings our total weight down to 2.3lb Which is a good point while we wait on our electronics to come in the mail.

Paint time

IMG_2543 IMG_2542

Paint and some Vinyl until we get the armour on to fill the extra weight.

Goals, 2014

Goals

35% Personal

Musical – 20% Theme: To become a competent musician, able to contribute with others in a simi-professonal setting

  •  Play a music set by the end of the second half, 2014. (Rock/Metal) *Bass Guitar or Rythym Guitar
    • Measureable: Play One Set
  •  Increase core music theory proficiency on bass guitar by end of second half, 2014
    • Lessons, weekly, or online aids / tests
    • Online Tutorials
    • Measureable: Transcription / Songwriting test of unknown song from tab -> standard notation, and inverse
    • Extra Credit: Transcription to standard notation from ear
  •  Techical Proficency on Bass Guitar by end of second half, 2014
    • Scale running in various forms.
    • Measureable: Be able to run/play the following patterns/scales:
      • Folk
      • Blues
      • Rock (pentatonic Minor scale)
      • Heptatonic (Egyptian)

Physical – 15% Theme: To maintain a level of fitness that can support an active lifestyle and future health. Quote-“Use it or Lose it”

  •  Snowboarding – Attempt to make the most use of this season.
    • Measurable: Have 20+ On Slopes days this season (H1 2014)
  •  Martial Arts – Continue to make use of and grow in this skillset.
    • Measurable: Be a member of a martial arts community.

Professonal – 45%

Theme: To develop into a leading member of my field, with professonal grade projects, both inside and outside of my employer

Core – 20%

  •  Work Goals – Designed during each half. TBD. Reflects into emplyer’s goals
  •  Promotion – Reach the rank of Applied Researcher II within the year.
    • Measureable: Obtain next rank within company.

Outside of Employer Professonal Development – 15%

Internet Security – 10%

Theme: To renforce my knowledge of the Internet Security Industry, and to maintain my skills in offensive security, and systems security, with a slight focus on compromising systems and reverse engineering

  •  Conference – Go to a professonal conference in the field of security
    • Measurable: Attend a conference.
  •  Knowledge – Watch Semenars and talks to stay relevant in the field.
    • Measurable: Watch/Particiapte in at least 2 talks a week, for a total of at least 1.5 hours of education.
  •  Apply – Take the skills gained from conferences and lessons, and put them into practice in a competitive enviroment
    • Measurable: Take place in at least one competition per Half.
  •  Research: Attempt to do some penetration / analysis of my own.
    • Measurable: Submit one bug/Security flaw a half in a publicly available service, like Google Chrome or Micorsoft.

Computer Graphics and Game Theory -5%

Theme: To continute to grow in my hobby of computer graphics and game design, with thoughts torwards developing a game down the road.

  •  Apply and Create – Come up with and develop a system from scratch that can be played by others. *Measurable: Delivery of one game
    • Must be using OpenGL or DirectX as drawing layer, with myself handling the interaction on that layer (No abstraction/graphics engine).

Software Development 10%

  •  Flying T Ipad Replacement Software *Measurable: Ipad app to replace current filemaker pro solution.

Spiritual – 10%

Theme: To return to my roots and increase my effort to ground myself spiritually and in my faith, giving me an ethical foundation to stand upon

  •  Church Involvement – To become involved in one church group *Measurable: Be an active member of one church group.

Social – 5%

Theme: To met new people outside the sphere of professonal or personal-professonal influences

  •  Friendships To make new friends outside of the sphere of professonal or personal development tasks. *Measurable: Add 5-10 new contacts, with 1-2 people whom would be considered “friends”

Family – 5%

Theme: Family is important. So is seeing them

  •  Visit Home
    • Measurable: Visit Home once a quarter

From gist on github: https://gist.github.com/Kurios/8447859

Test Driven Design

So these days, I’ve started to put together a platform for some work at work. Something involving timing and scheduling. (Yay for woefully underdescript descriptions of what I’m doing). Now of course, the interesting tidbit about this is not the software itself, as code is code, and end the end, there are many end products. The cool part is the design process and architecture. And for me, this means a first venture into TDD(Test Driven Design).

On my own, without any outside suggestion to do so, I am experimenting with TDD for this project. Making it clear this is fully my idea and experiment. Though why would I want to do such a thing to myself? Why would I want to decree myself, and cast myself into the world of unit tests? It turns out, that this is suppose to be a platform type piece, so in the back of my head, when I started drawing out a design on paper, my thoughts traveled to how hard is this going to be to maintain down the line. After all, I am just one code monkey type person, and one person can only do soo much if all he does it sit around and fix bugs on his prior projects.  This more or less lead me down the thought-path of I should most likely make some sort of attempt to validate what I’m doing. Make sure I’m doing it right. And make sure that when I change something, it doesn’t break everything.

And this is renforced by my choice of language. The first draft for the first class was done in scala. But as one of my co-workers put it, I more or less got fed up with scala’s functional nature, its desire to hate mutable objects. So I rebeled. Hard. Into the most mutable language I could find. So this quickly became a javascript/node.js project. The only downside to node in my option though is the fact that node has no constants. So the only way to have personal guarantees of functionality is to make unit tests for them. Ruby, another dynamic language, also has a similar philosophy in development to my knowledge. For testing platform, I’m using mocha and chai.

So we set out to write code, and write unit tests for code. Of course, comming from a… code of the top of your head mentality I suppose. Actually have no idea what you’d call my development style, I attempted to incorperate into it some unit tests.

To start with, I wrote a function, then I wrote some tests for that function. It was good. made me feel a hair more certain that my function actually worked. Then I thought up what I wanted to do next. wrote some skeleton code, wrote some tests. Then went back in to making all the unit tests pass mode.

Today, I hit a new mark. coded the unit tests first. Never done that before. So lets see where this monstrosity is headed…

p1

The skies blackened, and at last, we knew. The age of the sun was no-more. For at last she had fallen into her final rest, to hide behind the grey, to move into the realm eternal. No longer where we, her children, the ones who took her for granted, bathing in her greatness, yet showing no gratitude to the grace she rained down upon us. And as we took no notice of her glory, in its absence, we felt sorrow.

For until this day, we had never known what it was like to be without. Without her grace, without her warmth, we were lost. For each day prior, she had stood by us, raining her warmth down us. But now, we were without.

Some couldn’t handle life without her. They were left behind. We had no time for the weak, no time for ones who couldn’t handle the change. Of course, all of us were affected. But those of us who kept it on the inside, only crying out for the grace at night, for the warmth, raining down on us, something other than this grey, this endless purgatory we had been condemned to.  A world of the strength of character, strength of ones will, and the strength to survive in such a new world.

So I myself was a poor soul, thrown into this new world, tossed into a place less forgiving.  My role, to observe, to write, to record, so the future could remember this time. A land without life, a land without glory. This is the story of how we survived the dark times, how we lived without her glory.

May the song of this tale guide me, and tell it true. May the spirit of the times be transcribed. May I be granted with the gift to transcribe these events accurately, and may you be gifted with the wisdom to understand it. And may the future generations take this warning with credence, and understand it. For all can be given with grace, and within grace,  true understanding can be granted.

To tell this tale in truth, we must return to the time when the sun died. We must travel to when the grey first rolled over our world.

We were a happy people in her grace, we moved around in the light, her rays shining down on us. In her light we bathed, and in her rays we were happy. By no means am I claiming that this was a perfect time. Like any age, the age of her grace had its problems. But in general, we were a happy people, her rays bringing a special light into our lives.

We were also a blind people. We sat in her grace, the world bright and green about us, and we took it for granted. We walked with the assumption that she would always be there for us. That she would take care of us, watch over us. Of course, as you all know, that was quickly proven wrong.

 

Lake Summit

Hiking in the rain is well worth the rewards (Sometimes)

Lake Summit Overlook Post Rain
Lake Summit Overlook Post Rain
Lake Overlook Itself... Oh wait, all we can see is clouds (If you look closely enough, you may be able to see that the lake is ~4 feet from the camera.
Lake Overlook Itself… Oh wait, all we can see is clouds (If you look closely enough, you may be able to see that the lake is ~4 feet from the camera.)

 

 

 

 

 

 

 

 

 

 

 

Drove some city boys up into dem hills dis weekend. Tit was beautiful. Both the scenery AND the faces and reactions of a pair of city folk traveling on a dirt trail in a car up the side of a mountain (A trail that had traffic going both ways, and was one lane wide). And that guy who was waving a rifle? You made the trip soo much better. Scared the shit out of my passenger as you inspected the chamber of the gun. (as the little kid next to him shot targets… but my passengers didnt see the kid. They were too focused on the dude they thought was shooting randomly into the air 😛 )

Kill The Persistance

One of the less fun things about playing with a lot of data is the fact that you never seem to have enough memory to hide it all in. Even in the magical land of the Hadoops, these issues can show up if you forget about the scale of your problem. Though, honestly, you should ignore the scale of the problem on truly big problems, as thinking about it too much only causes headaches.   Instead, Just remember, that when you play with a lot of data, everything must DIE! And the quicker, you, the glorious general-programmer performs the deed, the better. After all, every element we leave alive is another element that exists somewhere, eating our precious resources.   Its also funny to think that on this scale, even Java programmers have to worry about memory management (GASP! Java Programmers worrying about memory management? Isnt that why we ran away from the (argueablly) better (promised) lands of C/C++? 😛 )   Though of course, examples are needed for anything…   So a simple example. A Hadoop reducer.

protected void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
    JsonParser parser = new JsonParser();
    LinkedList<JsonObject> objects = new LinkedList<JsonObject>();
    JsonObject user = null;
    for (Iterator<Text> itt = values.iterator(); itt.hasNext();) {
    JsonObject object = parser.parse(itt.next().toString()).getAsJsonObject();
        if (object.has("userId")){
            user  = object;
        }else{
             objects.add(object)
        }
        for (Iterator<JsonObject> itt = values.iterator(); itt.hasNext();) {
            JsonObject object = itt.next()
            object.add("userId",user);
        context.write(key, new Text(object.toString()));
    }
}

Very few lines of code, a grand total of 2 loops. And do you know what’s really special about this function?   It does this when used on a real dataset:

com.google.gson.JsonParseException: Failed parsing JSON source: JsonReader at line 1 column 1621 to Json at com.google.gson.JsonParser.parse(JsonParser.java:88) at com.google.gson.JsonParser.parse(JsonParser.java:59) at com.google.gson.JsonParser.parse(JsonParser.java:45) at hadoop.sampling.JoinReducer.reduce(JoinReducer.java:22) at hadoop.sampling.JoinReducer.reduce(JoinReducer.java:1) at org.apache.hadoop.mapreduce.Reducer.run(Reducer.java:176) at org.apache.hadoop.mapred.ReduceTask.runNewReducer(ReduceTask.java:650) at org.apache.hadoop.mapred.ReduceTask.run(ReduceTask.java:418) at org.apache.hadoop.mapred.Child$4.run(Child.java:255) at java.security.AccessController.doPrivileged(Native Method) at javax.security.auth.Subject.doAs(Subject.java:396) at org.apache.hadoop.security.UserGroupInformation.doAs(UserGroupInformation.java:1178) at org.apache.hadoop.mapred.Child.main(Child.java:249) Caused by: java.lang.OutOfMemoryError: GC overhead limit exceeded at com.google.gson.stream.JsonReader.nextQuotedValue(JsonReader.java:977) at com.google.gson.stream.JsonReader.nextName(JsonReader.java:783) at com.google.gson.internal.bind.TypeAdapters$25.read(TypeAdapters.java:667) at com.google.gson.internal.bind.TypeAdapters$25.read(TypeAdapters.java:642) at com.google.gson.internal.Streams.parse(Streams.java:44) at com.google.gson.JsonParser.parse(JsonParser.java:84) … 12 more

So truly productive behavior. The real question though is why? Why would seemingly innocent and normal code blow up on us like that? (Yes, I know some of you may be facepalming at this by looking at the function above. But if there wasn’t a problem with it, what would there be to write about? )   The big issue is we are attempting to have this do work on a massive dataset. Think 10s of Terabytes of data. That scale of data. So any data that we expect to persist needs to be destroyed. After all, with such a dataset, if it was only 1 million entries, a single “java boolean” would consume 1,000,000 bytes. (java is silly and uses 8bit booleans, yes…) (And ok, maybe that number is deceiving… as it is tiny… honestly. About a single megabyte. But just imagine the bloat on something bigger then a byte.)   But, our goal is to kill all the factors that can eat memory, because we are going to be “memory-aware” java programmers. So we need to kill the persistence, in regards to data. Now, as far as peristant, growing things, likely suspects are anything that Java would consider a collection. Of course, in our little snippet, the cause of all our troubles was the LinkedList. It grew and grew untill the GC died. And unlike in C, when the GC gets desperate, it just starts to eat all your CPU time in a futile attempt to salvage the situation.

Task attempt failed to report status for 617 seconds. Killing!

Poor task. It died a horrible, self-disgestive death. Killed by its own garbage collector (Lets see that happen to a C program No! A C program would just start overwriting itself. A way better solution. :P)   How do we fix it? Get rid of unnecessary collections. After all, how many times do we use a collection when a bit of elegance could have done. Or we make a second collection that is near identical to one we already have?

protected void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
    JsonParser parser = new JsonParser();
    // LinkedList<JsonObject> objects = new LinkedList<JsonObject>(); //Memory Issues!!!!!!!!!! KILL ALL THE PERSISTANCE!
    JsonObject user = null;
    for (Iterator<Text> itt = values.iterator(); itt.hasNext();) {
        JsonObject object = parser.parse(itt.next().toString()).getAsJsonObject();
        if (object.has("userId"))
        {
            user = object;
            break;
        }
    }
    for (Iterator<Text> itt = values.iterator(); itt.hasNext();) {
        JsonObject object = parser.parse(itt.next().toString()).getAsJsonObject();
        if (!object.has("userId")) {
            object.add("userId",user);
            context.write(key, new Text(object.toString()));
            }
        }
    }

And its argueablly sexier code? Maybe?   But alas, remember, Kill the Persistence.       (Tangent: Not saying “Big Data”… Big Data has soooo many issues… Even if  the data in “lots of data” is larger then what some “Big Data” Professionals get to play with… Don’t give into the hype kids. It isn’t cool.)

Seattle, Round 1

So, I have ventured into Seattle for the first time properly this past Friday night, and as it turns out, me and Seattle don’t like each other. Coming from Atlanta, something feels wrong about Seattle. Though, for the sake of argument, lets attempt to rationalize this a little, but, all in all, it feels like walking about South Atlanta. In the good parts. (Or so I’ve been told)

Downtown Seattle. The Good Parts.
Downtown Seattle. The Good Parts.

Of course, I may be biased, as a good-ol’ southern boy, living on the better side of the lake.  A wonderfuller place, one that seems to still maintain a degree of normalicy, one that seems to not be the local hub of the local anarchy society, with a litttle bit of KKK style fun thrown in there for style points.

But, like any place, Im sure it has a few positive points too. And when I find them, I’ll let you know. After all, like many things in this state, its all a mixed bag of pain and awesomeness, depending on what your talking about and who your talking to, and where you are.  But, lets take a look at the city itself in a bit more detail.

 

  1. Parking. And by that, I mean a combination of the lack of parking, and the feeling that your going to hit every car on every back street due to the parking density. Honestly, how do you take a street that was designed as a two lane street, Slam two rows of fully packed cars on either side of it, and then still expect people to be able to use it as a two way street? There is barely a single lane left after that crime of a park job. And as you drive (or creep, because you cant really drive in the state of Washington. The speed limits are all set to turtle speeds…) you get this naggy suspicion that your about to take out every car to your left and right. Makes you glad that you drive a tank of sorts sometimes. At least you know your going to take the least amount of damage to some extent.
  2. Look and Feel It took me a while to nail how to attempt to decibe this one,  but, I figure the best way to describe this would be a movie reference. Back in the old days, when movies where young, there was a movie, called Escape From New York. If I woulda dirven into the scene of that movie, I would by no means have been surprised. It already feels halfway that way.
    Another Average Day in Seattle Nightlife

    In fact, it is just oozing with this anarchist, grunge-y feel to it. Of course, for some reason, I am not surprised that some of the artists for Shadowrun come from this area. If they ever needed inspiration for one of their techno-punk worlds, they only needed to look out their windows. (All that’s missing after all is a few robotic eyes and arms)

  3. And on feel, lets go into The Feeling like your going to get shot no matter where you go. Maybe this is a little of my time in Atlanta, as people do actually get shot if they wander into the wrong parts of that city. (gasp, big surprise. People getting shot in the ghettos.) There are certain warning signs of course that your in one of those places, and theres certain signs that people tend to give off when you want to give them a little bit of extra attention, just in case. Now, in a city with a sparser pedestrian population, you can usually manage paying attention to all your potential threat vectors. The problem with walking around Seattle is EVERYTHING FEELS LIKE A POTENTIAL THREAT. Expecially to someone who came from a city where the threats are real.  So yah. Theres some issues there with me and the city in that regard.
  4. Its also filled with punks. Normally this isn’t too bad, but look at above. Punks, anarchists, and that general lot will always fit into the above category, along with anyone who dresses/acts provocatively. In contraspect, Atlanta has its punks, but they are alot more subtle about it. The south in general maintains a degree of subtlety. This is both good and bad. For one, it lets us hide the bad parts easier, and push them under the rug, let us think they arnt so bad because they are not loud and in front of us. Seattle, on the other hand, is BRASH. In striving to be unique, everyone paints a target on themselves. And the problem with targets is, they must be watched, else they might shoot you.

So maybe Im a paranoid southern kid, but Seattle has its demon magic way of really putting my paranoia into overdrive. So I’ll stay on my side of the lake. Its better over here.