Given a base class with a static method to be overridden by subclasses, is there a way to determine the type of its subclasses?

Oh totally, right? Java objects have the ability to look inside themselves and perform introspection, so objects always know their own classes. Introspection and Dynamic Method Binding in Java allow us to have some seriously sexy polymorphism going on by default (without having to declare any of our functions virtual). Yay! Ok, now let’s go through a little mini-review of polymorphism in Java.

Polymorphism

Polymorphism really is a girl’s dream: it means you’ve got the magical ability to know exactly what I want even if I don’t tell you or maybe even if I lie about it.

Here are some Pokemon!

// Pokemon is totally the hip/unhip thing to do right now.
public class Charmander
{
    public void whatsYourFavoriteJavaPrimitive()
    {
        System.out.println("char! char! (mander)");
    }
}

public class Charmeleon extends Charmander
{
    public void whatsYourFavoriteJavaPrimitive()
    {
        System.out.println("Char! Char! (meleon)");
    }
}

public class Charizard extends Charmeleon
{
    public void whatsYourFavoriteJavaPrimitive()
    {
        System.out.println("CHAR! CHAR! (izard)");
    }
}

So okay, now we’ve got our three levels of Pokemon and we’re ready to rock. Let’s code up a Driver class real quick to spawn a buncha Pokemon and see what happens when we ask them about which Java primitive is their favorite. Some of them will be shining examples of honest Pokemon and correctly declare their own object type, others will be lying little turds pretending to be their parents to get into the PokeBar.

public class Driver
{
    public static void main(String[] args)
    {
        System.out.println("Normal Declaration");
        System.out.println("------------------");
        System.out.println("Charmander as itself:");
        Charmander mander1 = new Charmander();
        mander1.whatsYourFavoriteJavaPrimitive();
        System.out.println("Charmeleon as itself:");
        Charmeleon meleon1 = new Charmeleon();
        meleon1.whatsYourFavoriteJavaPrimitive();
        System.out.println("Charizard as itself:");
        Charizard izard1 = new Charizard();
        izard1.whatsYourFavoriteJavaPrimitive();

        System.out.println("Polymorphism");
        System.out.println("------------");
        System.out.println("Charmeleon pretending to be a Charmander:");
        Charmander meleon2 = new Charmeleon();
        meleon2.whatsYourFavoriteJavaPrimitive();
        System.out.println("Charizard pretending to be a Charmander:");
        Charmander izard2 = new Charizard();
        izard2.whatsYourFavoriteJavaPrimitive();
        System.out.println("Charizard pretending to be a Charmeleon:");
        Charmeleon izard3 = new Charizard();
        izard3.whatsYourFavoriteJavaPrimitive();
    }
}

And let’s take a close look at the output:

leah$ java Driver
Normal Declaration
——————
Charmander as itself:
char! char! (mander)
Charmeleon as itself:
Char! Char! (meleon)
Charizard as itself:
CHAR! CHAR! (izard)
Polymorphism
————
Charmeleon pretending to be a Charmander:
Char! Char! (meleon)
Charizard pretending to be a Charmander:
CHAR! CHAR! (izard)
Charizard pretending to be a Charmeleon:
CHAR! CHAR! (izard)

Polymorphism is indifferent to your sad attempt to confuse it by declaring an object as its parent’s type! Polymorphism don’t care. Polymorphism don’t give a shit, it just takes what it wants.
Anyway, so that’s how polymorphism with method overriding normally works in Java. But what happens in the situation we talked about above with the superclass with static methods?

When Polymorphism Goes Wrong

You guessed it, something goes wrong. But let’s go ahead anyway with full knowledge and modify our Pokemon from before to make all our whatsYourFavoriteJavaPrimitive() methods static so we won’t have to instantiate an object every time we want to call their method.

public class Charmander
{
    public static void whatsYourFavoriteJavaPrimitive()
    {
        System.out.println("char! char! (mander)");
    }
}

public class Charmeleon extends Charmander
{
    public static void whatsYourFavoriteJavaPrimitive()
    {
        System.out.println("Char! Char! (meleon)");
    }
}

public class Charizard extends Charmeleon
{
    public static void whatsYourFavoriteJavaPrimitive()
    {
        System.out.println("CHAR! CHAR! (izard)");
    }
}

And let’s go ahead and run the old Driver class and carefully examine our output:

leah$ java Driver
Normal Declaration
——————
Charmeleon as itself:
Char! Char! (meleon)
Charizard as itself:
CHAR! CHAR! (izard)
Polymorphism
————
Charmeleon pretending to be a Charmander:
char! char! (mander)
Charizard pretending to be a Charmander:
char! char! (mander)
Charizard pretending to be a Charmeleon:
Char! Char! (meleon)

wat.

All we added was a “static” keyword to the methods! We’re still coding in Java and the output is listed under the Polymorphism heading so it must be true Why don’t we see polymorphic behavior here? Why is this any different than before?

Regular methods in Java use dynamic binding by default – it basically doesn’t make up it’s mind about the object type until runtime. Static methods in Java use early binding at compile time entirely based on the reference you set for the object (and technically can never be overridden).

But I really really want polymorphism with static methods!

How can we make polymorphism happen anyway?

Let’s poke around some more and see if we can’t come up with something.
How does Java know what class an object belongs to? Well, in the Object class there’s a method called getClass which returns a Class object. Inside the Class object, we’ve got a method called getMethod which returns a Method object. Sheesh, Java really does have an object for everything.

Okay, so this Method class has a very interesting method called invoke which invokes a method (how meta).

Let’s take all this badass crazy break java ninja shit and drive it home!

public class Driver
{
    public static void main(String[] args) throws Exception
    {
        System.out.println("Normal Declaration");
        System.out.println("------------------");
        System.out.println("Charmander as itself:");
        Charmander mander1 = new Charmander();
        mander1.whatsYourFavoriteJavaPrimitive();
        System.out.println("Charmeleon as itself:");
        Charmeleon meleon1 = new Charmeleon();
        meleon1.whatsYourFavoriteJavaPrimitive();
        System.out.println("Charizard as itself:");
        Charizard izard1 = new Charizard();
        izard1.whatsYourFavoriteJavaPrimitive();

        System.out.println("Broken Polymorphism");
        System.out.println("--------------------");
        System.out.println("Charmeleon pretending to be a Charmander:");
        Charmander meleon2 = new Charmeleon();
        meleon2.whatsYourFavoriteJavaPrimitive();
        System.out.println("Charizard pretending to be a Charmander:");
        Charmander izard2 = new Charizard();
        izard2.whatsYourFavoriteJavaPrimitive();
        System.out.println("Charizard pretending to be a Charmeleon:");
        Charmeleon izard3 = new Charizard();
        izard3.whatsYourFavoriteJavaPrimitive();

        System.out.println("Without Instantiation");
        System.out.println("---------------------");
        System.out.println("Charmander:");
        Charmander.whatsYourFavoriteJavaPrimitive();
        System.out.println("Charmeleon:");
        Charmeleon.whatsYourFavoriteJavaPrimitive();
        System.out.println("Charizard");
        Charizard.whatsYourFavoriteJavaPrimitive();

        System.out.println("getClass.getMethod.invoke");
        System.out.println("-------------------------");
        System.out.println("Charmeleon pretending to be a Charmander:");
        meleon2.getClass().getMethod("whatsYourFavoriteJavaPrimitive", null).invoke(null, null);
        System.out.println("Charizard pretending to be a Charmander:");
        izard2.getClass().getMethod("whatsYourFavoriteJavaPrimitive", null).invoke(null, null);
        System.out.println("Charizard pretending to be a Charmeleon:");
        izard3.getClass().getMethod("whatsYourFavoriteJavaPrimitive", null).invoke(null, null);

    }
}

Ok, what does this give us?

leah$ java Driver
Normal Declaration
——————
Charmander as itself:
char! char! (mander)
Charmeleon as itself:
Char! Char! (meleon)
Charizard as itself:
CHAR! CHAR! (izard)
Broken Polymorphism
——————–
Charmeleon pretending to be a Charmander:
char! char! (mander)
Charizard pretending to be a Charmander:
char! char! (mander)
Charizard pretending to be a Charmeleon:
Char! Char! (meleon)
Without Instantiation
———————
Charmander:
char! char! (mander)
Charmeleon:
Char! Char! (meleon)
Charizard
CHAR! CHAR! (izard)
getClass.getMethod.invoke
————————-
Charmeleon pretending to be a Charmander:
Char! Char! (meleon)
Charizard pretending to be a Charmander:
CHAR! CHAR! (izard)
Charizard pretending to be a Charmeleon:
CHAR! CHAR! (izard)

OMFG Did we really just do that? I think we did! Even when Java didn’t want to dynamically bind our static methods, we made it happen anyway! Polymorphism – it’s super effective!

Leah's Ninja Badge

The Ninja Badge was absolutely phenomenal this year at DEFCON 18. Each badge had a playable ninja character which could wirelessly battle other ninjas within a 10ft proximity. You could even complete quests and obtain items!

The quests ranged from simply visiting various vendor booths to defeating bosses walking around the conference.

There was also the CAEZARS CHALLENGE mode unlocked by typing in the Konami code (Up Up Down Down Left Right Left Right B A). A series of about 10 different challenges would appear for you to solve. I spent a few hours working through them, fascinated.

The last Caezar’s Challenge asked you to obtain the instruction pointer using 3 assembly opcodes. The accepted answer was actually a flawed solution, so it took asking an organizer to actually solve the final challenge. I’ll just chalk that one up to social engineering

The social dynamic between ninja badge holders was so incredible – I remember a few times being introduced to other ninja badge holders and mentioning that we’d already been ninja fighting that day during talks, lol.

The Ninja Networks website has in-depth details about this year’s badge. Wired has the in-depth details about the badge specs if you’re interested in reading about the capabilities.

I hear they’re selling on eBay for around $500 or you could really just take the design files below to a manufacturer and have them make you one.

Oh, and if anyone has a scan of the badge instruction manual, I would greatly appreciate it as mine disappeared

My friend C4 gave me the ninja badge source code if you’re interested in hacking the badge or sending the design off to a manufacturer to obtain your own! I’m working with him right now to make it into a dev board among other things.

EDIT: Krux obtained the design files.

I started by googling TRON Costume and found some excellent resources for building my own TRON Costume. But alas, I stumbled upon TRON Guy and came to the sad realization that I would never be cool enough to top that. So instead of creating yet another TRON Costume, I decided I would find some of my favorite pieces of clothing and line them with electroluminescent wire to give the whole ensemble a more modern and unique feel.

TRON Fedora Lit Up in the Dark

I scoured the house while my husband was out of town and found the perfect piece: his favorite fedora.

I thought I would surprise him with a sweet pimped-out EL TRON Fedora he can wear on the midnight showing of TRON…

I lined all the seams of the hat using bookbinder’s thread and needle because the fabric was actually quite tough and I couldn’t get a regular sewing needle through it without really hurting my fingers. As you can see from the pictures, I spaced the loops about 4-5 inches apart on the edges which end up being completely invisible in a dark room with the fedora lit up!

My aim was to not cross-over the same place twice with EL wire, so I switched to regular black stranded wire to link two different EL wire segments together.

My husband hasn’t seen it yet, so I hope he won’t be mad that I had to cut an itty bitty hole in the back of the hat to feed the connector through, lol.

Front of TRON Fedora

I’d never worked with electroluminescent wire before this project. It’s actually quite a pain in the arse to solder. If you don’t buy the silly EL-wire-stripper tool, it’s a delicate art to strip the wire coating without breaking the two tiny angelhair wires that run along the outside coating. Before working firsthand with the stuff, I audibly scoffed at the idea of buying a “wire stripper tool” specifically made for electroluminescent wire – why not just use a regular wire-stripper? Now I know.

Back of the TRON Fedora

The back of the hat didn’t turn out quite as beautiful as I’d imagined in my head, but not hideous either. I started by only lining the top and bottom of the hat with one long piece of EL wire. After deciding that didn’t have quite the wow-factor I was looking for, I added in two more pieces around the rim and middle portion of the fedora. I could have linked the wires together to end up with one very long strand connected with tiny black wire, but instead I decided to centralize the crazt mess of wires to the back of the hat where it would be the least noticeable.

Leah Sporting the Fashionable TRON Fedora

Anyway, that was part one of the TRON Costume ensemble! I’ve already got a dress picked out I’m going to line with another color (orange or pink, I haven’t decided yet).

I hear Daft Punk is doing the soundtrack for TRON: Legacy – maybe when I’m brave enough I’ll actually have some working Daft Punk Helmets. I’m SO EXCITED about this movie, I can’t wait!!

Quite frankly, software development needs a makeover.

Office Space made light of the whole situation by poking fun at one of the employees. His job was solely a mediator between the users and the programmers, because “programmers can’t talk to people”. Sadly, this actually happens in the real world outside of comedy movies. Fellow programmers, this is not something to be proud of and should be treated as a weakness in your coding ability! Here’s a good place to start:

One of my favorite classes I’d ever taken in Computer Science was a course taught by Dr. Eck Doerry at Northern Arizona University entitled “Advanced User Interfaces”. I consider it life-altering because I felt like I stepped out of that course with a fresh new look at the software development cycle and how everyone currently operating in the industry has it all wrong and it’s my job to educate the world (Call me naïve).

The 7 Golden Rules of Usability

Here are the seven commandments to follow when actually laying out your user interface (this is ideally after you’ve completed initial user surveys):

1. Consistency: Your interface should follow a pattern of control structures in addition to a universal “look and feel”. Your system should also be consistent with the user’s mental model of the problem.
2. Design for Evolving Expertise: Your system should have a very small learning curve for new users (perhaps include an introductory tutorial explaining how to use your system) and should also be capable enough for more advanced users to quickly perform actions without hassle (The infamous Microsoft Word Paperclip Helper should never appear for advanced users, for example).
3. Feedback: Your system should always indicate the status state and progress for the user, using the appropriate conventions. A spinning indicator is an acceptable way to show the user the system is taking only a few moment to process a request, but any process taking longer should be given a full progress bar.
4. Design for Error: Your system should disallow error wherever possible – grey out possible new actions during processing, use very strict input validation, etc. Additionally, your system should handle errors in the most prudent way possible – no cryptic error messages with application crashes. Exceptions should be thrown to an error-handling mechanism that determines the best course of action to take in the event of a failure at any step of the way.
5. Reversal of Action: Humans make mistakes, every action taken by the user changing the system state should be completely reversible. Studies show that if users realize they’ve made a mistake, they tend to realize only a few seconds after taking the action (possibly by second-guessing themselves?). Even permanent delete functions should be stored in a temporary place to allow for reversal (much like the Recycle Bin).
6. Sense of User Control: Users should always be the initiators, with the system passively receiving actions without any hidden automatic behavior behind the scenes. This isn’t always possible, however. In the event that your system is modeling real-time data, the user should always be given the control to halt or change the system at any time.
7. No Rote Memorization: Users should not be expected to keep data in their short term memory to operate your system – for example, if data from three screens ago needs to be entered again: give all the information to the user on the same page (to be used as reference) rather than expecting him to recall it.

And for funsies, here are some design documents our UI Team used for our Final Project in the class:

• Design Plan
• Usability Report
• Final Results Presentation

So everything I could find on the Amazon MP3 Store, I’ve linked to here in the playlist because the truth is: geeks are a very small clique that simply doesn’t generate as much income for the artists as your normal, run-of-the-mill boring pop culture radio blether. So please, support the artists – they really need your help!

Geekster Rap

Much of the great geek music collection here owes much to the underground Nerdcore subculture. But I’ve classified the music even further by distinguishing the vulgar, testosterone-infused vulgar Geekster Rap (which is almost a direct parody of classic Gangster Rap) from the rest of the Nerdcore scene.

Monzy

Monzy: So Much Drama in the PhD [NSFW]

This was a Stanford grad student’s masterpiece – it’s *FILLED* with algorithms and terminology we’re all so familiar with from CS core classes. NSFW! Download mp3 (Free)

My flow is so intense that I will overflow your buffer,
Corrupt your stack pointer makin’ all your data suffer.
I’ve got saturated edges but your flow is sparser,
Real gangstas sip on Yacc; instead you generate a parser.
While you’re busy poppin’ stacks I’ll pop a cap in your skull,
While you smoke your crack pipe I’m gonna pipe you to /dev/null.
I may not have a label but I rap like a star;
I’m an unsigned long int and you’re an 8-bit char.

Your mom circulates like a public key,
Servicing more requests than HTTP.
She keeps all her ports open like Windows ME,
Oh, there’s so much drama in the PhD.

I run gmake and gcc,
And I ain’t never called malloc without calling free.
I’ll beat your ass until it’s colored like a red-black tree
‘Cause there’s so much drama in the PhD.

(Ode to the DEFCON) Badgez

DEFCON 15′s Badgehacking Team Winner, Team Osogato, went all out on their badgehacking submission: they got a friend-of-a-friend (The Brothers Grimm) who was a Nerdcore rapper to create a rap from the poem Joe Grand wrote in the DEFCON schedule booklet that year. It sounds really great too! Download mp3 (Free)

Secrets From the Future Album

Secrets From the Future

MC Frontalot is probably my all-time favorite Nerdcore Rapper. He’s got an exquisite sound and an intuitive sense of (geek) culture in his music. His track, “Secrets from the Future” has a god-like quality to it: I think it was even composed at DEFCON? Man I would have killed to see him at DEFCON. Anyway, lyrics are here. And also, Download the mp3 (Free) from his website. Or, do the right thing and buy the entire album!

Anti-MPAA Sticker of My Youth

Fuck the MPAA [NSFW]

Oh yeah, back when I was in 6th grade the cool thing to do was post those bright yellow “STOP THE MPAA” bumper stickers all over town. Several of the payphones at school had those bumperstickers plastered all over them (I can neither confirm nor deny placing them there). The Futuristic Sex Robotz took it to a whole new level of cool with this song. Oh and pretty much anything by FSR is obscenely vulgar (but awesomely geeky), so obviously nowhere near safe for work: Download mp3 (Free)

Partytron (Electronic)

The Geeks Were Right & The Conductor

The Faint has quickly become one of my favorite artists of all time. They’ve got this grungy, industrial sound plus kickin’ bass beats: I dub this new genre… Partytron! “The Conductor” is about the conductor of an orchestra, stepping up to the stage and taking control of the music. “The Geeks Were Right” is all about the Sci-fi Prediction that we’ll all become robots someday actually comes true. The Faint gets a HUGE less-than-three from me

The Geeks Were Right

The Conductor (Thin White Duke Remix)

8-bit Remixes

So, this is probably the most represented genre of the geek music I listen to. Everyone and their mother has probably heard a video game theme remix somewhere along the lines. So I’ve decided to focus on only the *good* ones, lol.

RAC's Nintendo vs. Sega EP

RAC’S Nintendo vs. Sega EP

I can’t pick my favorite from this album: EVERYTHING is great. RAC is pretty much the crowned king of video game remixes in my world. Sonic and Mario getting together on the weekends for an 8-bit Party? Oh YEAH! The Remix Artist Collective Agency (RAC) is a group of artists that remix all kinds of popular music: I pretty much read (RAC Remix) next to any song as (Eff-YEAH Remix). Download zip of entire album (Free)

Anything by EEPROM

EEPROM is pretty much the God of Leah’s Musical World. Everything he touches turns to gold – I honestly haven’t found any song that he’s created that my mind hasn’t been blown countless times over.

EEPROM Remix of Weezer’s Say It Ain’t So: mp3 Download (Free)

The Beatles’s Lonely People (EEPROM Rigby Remix): mp3 Download (80¢)

EEPROM Remix of the Safety Dance: mp3 Download (80¢)

EEPROM Remix of Human Robotics: mp3 Download (80¢)

EEPROM Remix of OneRepublic’s Apologize: mp3 Download (80¢)

EEPROM Remix Rick Astley’s Never Gonna Give You Up (Rick Roll): mp3 Download (80¢)

]]> http://leahshanker.com/2009/08/18/my-favorite-geek-music-tracks-playlist/feed/ 0 Leah Monzy Secrets From the Future Album Anti-MPAA Sticker of My Youth The Geeks Were Right by The Faint The Conductor (Thin White Duke Remix) by The Faint RAC's Nintendo vs. Sega EP http://leahshanker.com/2009/08/05/defcon-0x11-post-mortem/ http://leahshanker.com/2009/08/05/defcon-0x11-post-mortem/#comments Wed, 05 Aug 2009 18:33:32 +0000 Leah Shanker http://leahshanker.wordpress.com/?p=318 ]]> After five consecutive years of watching cool people show off incredibly cool things, I decided to take a whole different approach to DEFCON this year. A number of my friends (including my wonderful husband Matt) took part in the Mystery Challenge this year after solving the initial registration puzzle a month before the conference started. Ever since I was a little girl, I’ve always had a soft spot for pen-and-paper ciphers and I knew that I would have an absolute blast joining the Mystery Challenge team. So, in a strange effort to enhance my character – I joined a badgehacking team instead

Our Badgehacking Team: Leah, Kenji & Matt

I had been preparing with Joe Davidson, Kenji Yamamoto and Matt Wyant for a number of months leading up to the badgehacking competition. To my great dismay, by the time I got to DEFCON (Thursday evening) – they were out of actual badges! I moped around, seriously considering joining the Mystery Challenge team and throwing up my hands in defeat at badgehacking.

But my faith in humanity was reaffirmed! A random friend from Twitter (@Ancients) picked me out near the Skyboxes and traded his real badge for my paper badge, “I would rather someone who’s actually hacking the badge have it instead of me”. I was in heaven! What an incredibly nice thing to do!!! Later on during the conference, I added some cool blinky lights to his badge in thanks (he also had to wait in the enormous badge exchange line the next day).

Check out the Wired Article for an in-depth look at the DEFCON badge!

After pouring over the source code and determining that the point of the badges was to get all the different badge types (“Contest”, “Speaker”, “Uber”, etc.) together to display a neat message – my eyes went to every badge that passed by me in the hallways. I was looking for someone who seemed friendly enough to let me borrow their non-human badge for I2C communication to test out the results. In my frantic searching, I found myself alone in an elevator with someone who seemed to have a cooler badge than I did – two rows of 17-segment LED displays that ate my little rainbow blinky LED for breakfast.

I asked him about his badge, “Is that the Blackhat Badge this year?” (Blackhat is the $2000/entry security conference you normally only attend if your employer pays for it)

“No, it’s the Ninja Party Pass.” I was stumped. My understanding was there was a “party badge” for $20-30 for anyone who only wanted to attend the DEFCON parties without paying the full entry into the conference. How could they possibly have received a cooler badge than mine?

He seemed to realize I was stumped. “It gets you into the most VIP party at DEFCON”. The elevator had arrived on his floor and he disappeared forever. Again I was stumped – to be honest, I never really had to worry about party entry at DEFCON (in fact, I had to escort Jeff Moss / Dark Tangent into a party last year because the bouncer didn’t know who he was). So I did a little bit of research and found out that the Ninja Party Pass was a required item for anyone entering in the Ceazar’s Challenge this year! NOW I wanted one! But by the time Friday night rolled around, everyone I asked about the Ninja Party Pass badges had said they’d all been distributed.

So I forgot about it for the time being and just hung out in the hardware hacking village – supposedly working on my badgehacking project. It was getting to be closing time for the HHV, and on my way out I notice a girl huddled over a complex-looking circuitboard, furiously soldering and muttering to herself. I was intruiged – I asked what she was working on and if there was anything I could do to help (being a newly appointed expert solderer). She mentioned her name was Amanda Wozniak from MIT and she designed the Ninja Party Pass Badge this year. They had apparently received a bunch of broken ninja badges that needed to be soldered up so she could give them out to her favorite people on Friday night.

“Maybe you should consider giving out the badge to someone who could fix it?” I suggested, merely in passing.

Leah-Corrected Ninja Party Pass Badge

She shook her head and mentioned she hadn’t released the schematics yet, so fixing it would be pretty hard for anyone except her.

And then it dawned on her – she turned to me and asked “Hey, do you want to fix it? It would save me soldering time and picking someone at the party tonight!” I hugged her and happydanced all the way to the contest area to solder up the board.

At the actual ninja party, I met a few goons who were ecstatic that I carried around a butane-powered soldering iron to fix solder joints at the actual ninja party. Vodka-Red Bulls and Soldering: Best party evar!

After the Ninja Party, my focus went entirely to finishing the badge hacking project – a tamagotchi hooked up to a breathalyzer. The idea was that your digital badge-pet would get “thirsty” and you would need to immediately find the most drunk person in the room to blow into the breathalyzer to keep your pet happy.

See more about it on Forbes: http://www.forbes.com/2009/08/04/hackers-contest-defcon-technology-security-hackers_print.html

So, although I’m a little bitter about Zoz, Joe Grand’s co-host on Prototype This, winning the badgehacking competition this year: I’m SUPER excited about going back to DEFCON next year!!!

]]> http://leahshanker.com/2009/08/05/defcon-0x11-post-mortem/feed/ 11 Leah Our Badgehacking Team: Leah, Kenji & Matt Leah-Corrected Ninja Party Pass Badge http://leahshanker.com/2009/07/06/first-nau-cs-department-newsletter-published/ http://leahshanker.com/2009/07/06/first-nau-cs-department-newsletter-published/#comments Mon, 06 Jul 2009 15:21:49 +0000 Leah Shanker http://leahshanker.wordpress.com/?p=304 ]]> Although I try to hide it nowadays, the original intent of this blog was largely self-serving: a professional portfolio to showcase my accomplishments for prospective clients and employers. Once I began actually writing, however, something stirred within me to breathe life to the internet with my helpful tutorials and unique viewpoints. What I’m trying to say is: Please forgive the occasional personal plug as my heart is mostly in the right place   Ok, back to our regularly scheduled program!

From the time I started as a freshman (dual-majoring in Mathematics and Computer Science – I was such an idealist back then), I’ve watched the NAU CS Department blossom into a paragon of what a Computer Science Department should be. I was honored last semester when Professor Steven Jacobs asked me to write an article for the first issue of the NAU CS Department Newsletter because it felt like I would go down in history as having even a tiny part in the advent of its success.

Truth be told, the most influential event in the department change took place on the day when Dr. Eck Doerry assumed the CS Department Chair position two years ago. He’s famous amongst the students for his high expectations, awe-inspiring class lectures and fiery passion for ground-breaking positive change. I’ll now give him the floor in the first published issue of the NAU CS Department Newsletter:

NAU Computer Science Department Newsletter, Spring 2009 (Check out my article on Page 2!)

Overall, the event was a success! We stayed until the wee hours of the morning of the graduation ceremony to actually complete the projects, but MAN did those graduates look cool! When I graduate next year, I’m thinking of using something even cooler like the electroluminescent sheets!

Martha Stewart's Engineering Handbook

Lately I’ve been hanging out with the Electrical Engineering majors in the upstairs electronics lab (they’re actually not as horrible as the other Computer Science majors would have you believe ) and one of them had dubbed me the “Martha Stewart” of Embedded Systems / Electrical Engineering because of my unusual take on compensating for component datasheet un-usability. Let me start this story off from the very beginning, a mere four months ago:

I was a total EE noob: no electromagnetism from Physics II, no introduction to circuits/components – heck I’d never even made a lemon battery! Before starting my Embedded Systems class this last semester, I was pretty much schematic-illiterate. The CS program here didn’t require me to take the “Introduction to Circuits” EE course as a requirement like in previous semesters, so I both lucked and missed out in that regard. I knew taking an upper level Computer Science elective based around Electrical Engineering principles would be difficult for me (especially considering nearly everyone else in the class had professional embedded systems experience outside of school). So I offered to buy some lunch for the Electrical Engineering majors upstairs in the lab in exchange for their patience in answering some ridiculously easy questions about circuits and components (Kenji couldn’t contain his laughter when I asked him to explain what a transistor was). So aside from voluntarily becoming the butt of nearly every Computer Science major joke they could throw at me, I learned a remarkable amount about how Electrical Engineers tend to approach the usability problem…

*crickets chirping*

Snip of Schematic from my RFID Reader Project

That’s right, there is no approach! Or rather, you could say there’s too much benevolence amongst Electrical Engineers for the “way the historical engineers of the past” got things done that nothing seems to update in the field solely for usability reasons. Here’s your solution to the usability problem: Suck it up and rub some dirt on it!

Take, for instance, my schematic on the right. The U4 Component is what I’m referring to.

Go ahead, I’ll give you ten minutes to scour through the boxes and lines on the schematic to actually locate it on the page…. (Hint: it’s on the right side)

Now, as a Computer Scientist in training I know all about the value of abstraction: it allows the programmer to embrace the natural human way of thinking, leading to more elegant and bug-free code. When constructing schematics, there is a clearly defined need for block diagrams (details abstracted away for clarity). Obviously, we don’t need to know about the tiny little gates inside of an integrated circuit in order to use one.

But take a look at U4. It’s a binary counter IC, but you didn’t really need to know that. All you need to know is where to hook up the wires on the component: easy, right?

So I go ahead and start hooking up the wires just like it says on the block diagram and I come across something very curious…

U4 Block Diagram First Wiring Attempt

Ok, so I’ll give them the benefit of the doubt here…maybe the pin locations aren’t in the same place depending on what kind of pin packaging I order? Let’s check with the datasheet:

Connection Diagram from the 74HC4060

Nope…they are all exactly the same regardless of what kind of packaging you order for this component… Wow. So you’re telling me there’s this completely unnecessary layer of abstraction for this component on my schematic? What a complete and total waste of my time!

This isn’t the only example…I could go on an endless rant about how there’s a severe lack of intelligent standards when it comes to IC pinouts: The “U” shape means the top of the component…except if you’re looking at a PIC or if it’s the second Tuesday of every third month from a randomly chosen start-time in a proprietary religious calendar.

So most of my time working on my Embedded Systems projects this semester has been spent combing through every single component datasheet trying to find the useful gems of information even though this should be a relatively simple process: hook wire 1 to pin 1 and go.

Ok, enough ranting. Here’s my crafty, “Martha Stewart” solution to the problem:

My solution to schematic/datasheet chaos

Naturally, the only useful tidbit of a datasheet (pinout diagram) is always at the very end of the document…unless you look there first! I printed out only the pages of the datasheets that housed the physical pin locations (or wrote them out myself if they weren’t even provided by the manufacturer…annoying), cut them out and pasted them onto my schematic to save on context switching time. So really in order to begin a project, I have to get out my scissors and glue and artfully create a  mashup (flashback to gradeschool craft time) for every single schematic I’m ever given in order to save myself countless hours of repetitively retrieving the same information from each of the component datasheets. Phew!

BTW, I found an excellent resistor color band calculator online during my work that I wanted to share with you all – saved me a ton of time

(…why can’t they just list resistance right on the resistor? I mean, I’m all for rainbows, but really…)

Boris is invincible!

Yes, yes, we all went through similar situations in high school where flying your geek flag was pretty much like taping a big juicy red target on your back and handing the rest of your graduating class paintball guns: it usually didn’t end well for us then.

But, the wheel turned and little geeks grew into bigger geeks and trotted off to college to study the science of geekery. They soon noticed that being a geek wasn’t a bad thing anymore, in fact it was even cool here.

You mean to tell me I can be as geeky and obscure as I’d like and everyone around me will actually understand and maybe even praise me for it? Do you have any idea how proud that made me?! So proud that I never bothered to notice how many normal people I’d alienated along the way trying to be as elitist as possible…

Sadly, the real world isn’t entirely made up of geeks. So, how do we geeks evolve and adapt to it? Skillfully, as always. By studying the algorithm to degeekify, of course

(This comes from an interesting discussion lead by my friend Murphy & my professor Dr. P) Let’s take for example, the linux file system structure:

/sbin System binaries used by the sysadmin. (Oh yeah, they can also be in /usr/sbin so check there too!)

/bin System binaries used by the sysadmin or regular users that are super important. (Oh, also check out /usr/bin for the less important stuff. Oh and also /usr/local/bin. So yeah.)

/dev Device nodes (not program development space).

/etc Config stuff

/lib System files & libraries

/tmp Temporary files

/var Any kind of logs or temporary configuration files (not in /tmp?) . And web stuff. Wait, what?

True die hard linux fans will refer you to some kind of guru on the filesystem structure, who will angrily rant about how linux applications developers are idiots who have no idea where things are supposed to go; or sysadmins who put modules in the wrong places… HOW DARE THEY misinterpret this cryptic and ambiguous filesystem structure! C’mon, if even the linux applications developers (fellow geeks) can’t even figure out where things are supposed to go, there’s obviously a flaw in the design of the system (Way to go, gobo linux!)

Since we’re picking on Unix anyway (pretty much the governing body of the design of current operating systems), let’s go a bit further.

$ tar  -xvf file.tar
$       ... wait, you're done or you're just stuck? hello?

So when a command on the Unix commandline executes successfully…nothing happens! I mean, I guess you got no errors…no news is good news? Sure, we’re smart geeks and can used to this notion, but this is still an inherent flaw in the design of the system!

And really, how effective is a terminal where you have to refer to the documentation (manpage) every time you try to execute a command you haven’t used in a while? We need some coherent standards for arguments across linux applications!

Let’s go with another example, this time with less…flame war bait:

So, you’re a software engineer. You have to conduct user surveys of your target user group before beginning to design your software architecture to gauge what a good use of your development time might be. So, you ask exactly what you want to know:

1. For the user selection panel, would you rather have a drop-down box or a Jtextfield you can enter your own data into? (Please specify if auto-complete would also help…)

Natural, right? You asked what you wanted to know. Exactly like calling a function: you pass (ask) exactly the correct parameters in the indicated order (questions) to extract your necessary information (survey data) from your data store (person). You even went as far as to suggest a helpful feature! (You’re so thoughtful ^-^ )

I’m sorry to have to be the one to tell you this…but (most) people aren’t functions. There is a fuzzy disconnect between what you want to know and what you really should want to know with user surveys. Normal people have no idea about their preference between two different technical components: they’ve never really thought about it before… and honestly, they really shouldn’t have to.

Geeks inherently worship the machine. User misunderstandings (PEBCAK…or PEBKAC… man that acronym needs a standard ) are interpreted as a problem of a lack of user knowledge, not even considered to be a flaw in the design of the system.

Yes, computers are simply just tools. But too often we forget that computers aren’t just physical tools like a shovel; we can actually redesign the computer depending on our needs. Sadly, we are not good enough to completely redesign a human from the ground up, regardless of how angrily we complain about the stupidity of our users. The only thing left is to redesign the system…think of it as teaching the computer to evolve along with humanity.