switch(axis) {
case 'x':
rx = offsetX;
ry = (offsetY * Math.cos(angDist)) - (offsetZ *Math.sin(angDist));
rz = (offsetY * Math.sin(angDist)) + (offsetZ *Math.cos(angDist));
break;
case 'y':
rx = (offsetX * Math.cos(angDist)) - (offsetZ *Math.sin(angDist));
ry = offsetY;
rz = (offsetX * Math.sin(angDist)) + (offsetZ *Math.cos(angDist));
break;
case 'z':
rx = (offsetX * Math.cos(angDist)) - (offsetY *Math.sin(angDist));
ry = (offsetX * Math.sin(angDist)) + (offsetY *Math.cos(angDist));
rz = offsetZ;
break;
}
return new THREE.Vector3( cTarget.x+rx, cTarget.y+ry, cTarget.z+rz );
}

In addition, I wrote a special Ray tracing algorithm that sends a ray from the mouse touch point through 3D space, and checks every particle or object in the way, and returns an array of those that are intersected by the line. A variant of this was added to the Three.JS library (my first pull request, yay!). I rewrote the algorithm from this math course:

target_point = object.geometry.vertices.position;
starter_vector = target_point.clone().subSelf(origin_point);

var dist = target_point.distanceTo(intersect_point);

As you touch a star, the touch finds the closest star (within a certain touch radius), and then highlights that by redrawing a canvas shell around it. This then also searches through the star json database and shows the 4 closest stars (highlighted in their star color and info) at the bottom left of the screen.

//=======================================
function generateSunTexture(color, size, showShell) {
var size = (size) ? parseInt(size*24) : 24;
var showShell = (showShell) ? showShell : false;
var canvas = document.createElement( 'canvas' );
canvas.width = size;
canvas.height = size;
var col = new THREE.Color(color);

}

Sorting is done by overloading the standard sort function (subtracting the distance field of object a from b to do a mergesort or selectionsort):
var closest_sorted = starscopy.sort( function ( a, b ) { return objectClicked.position.distanceTo (a.position)-objectClicked.position.distanceTo (b.position); } );

Much of the work was done to get the Star library, catch the touch events, and clean things up so that it would render all in Canvas (so that it looks good on iPhone, Android browser, as well as other common browsers). You can view it in action here.

People who looked at this item also looked at…

• Orrery Game: ver 2
• Government Mobile Applications
• About Jay
• Building applications for Tysons Corner
• Chumby Advanced Tricks

Related items

• HTML5 Map Tile JavaScript Game Engine, Part 1
• JavaScript HTML5 Image Caching
• Stellar Database
• Chumby Advanced Tricks
• Orrery Game: ver 2

I recently uploaded a Stellar Database that I’m using for many of my HTML5 animations to Gihub as Open Source.

This Stellar Database is made based on inputs from the Internet Stellar Database (ISDB). I took the isdb.mdb file and moved all of the data into an Excel XLS file, then rewrote many of the SQL queries as Excel functions.

NOTE: Writing complex data lookups/searching/linking using Excel is very inefficient, and results in multiple headaches. But, I was on a long flight, and was bored, and thought it’d be fun to see how far Excel functions have advanced since I used them 15 years ago.

NOTE: Excel functions have not advanced in 15 years.

Anywho, there are three JSON files that have different sets of data:
stars_all.json.js has 2800 stars in it, arranged in distance order and containing multiple fields like Galactic XYZ Position, Mass, Diameter, Color.
stars_1k.json.js has 1000 stars, but less data columns.
stars_named.json.js has 778 stars in it based on stars that seem to have actual names.

The Excel has two columns in the first sheet that auto-build the JSON strings, this should make it easy to export in different orders if desired.

It’s very difficult to adequately guess the star colors, as these aren’t recorded in web RGB formats, and weren’t in a useful dataset that I could find. I used formulae based on: http://outreach.atnf.csiro.au/education/senior/astrophysics/photometry_colour.html and other sources to try to guess the closest colors.

Galactic Alignment is calculated as X,Y,Z coordinates from doing a matrix rotation around the Local Stellar coordinates (which are calcluated from taking the Right Ascension and Declination based on solar coordinates and multiplying by distance). That basically means that these might be off by a large amount – so please don’t plan any NASA trips from these numbers.

If you would like to see these rendered in HTML5 (optimized for mobile devices), you can see them at: http://wecreategames.com/apps/StarPad/ – I think this looks especially cool on an iPhone, and was made using Mr. Doob’s awesome Three.JS library.

People who looked at this item also looked at…

• StarPad JavaScript Star viewer
• Orrery Game: ver 2
• Building applications for Tysons Corner
• Chumby Advanced Tricks
• About Jay

Related items

• HTML5 Map Tile JavaScript Game Engine, Part 1
• HTML5 Databases + Canvas
• 3d iPhone web apps
• Updated FlickrProxy
• iPhone Geotags

Just like every male nerd thinks they need a man-cave (preferably with a lab or in an underground bunker), they quickly realize that their baby actually does best in a well-equipped nerdsury.  I’ve found that when you are on the 2-am bottle-duty, you frequently wonder what time it is and how long feeding takes (usually with the goal of whining to your spouse or bragging to your coworkers about how tired you are).

A good clock with large digital numbers is a good investment – something to put in a place where you can see it from your feeding rocking chair. You’ll likely be so tired that you need some minor stimulation to stay awake, but anything as complex as conjugating words will be beyond your ability. Staring at numbers while feeding a baby seems like the extent of my mental abilities sometimes on 2 hours of sleep.

#10 – Digital Alarm clock

Once you get your rhythm down, you’ll find that routine is very good for your babe’s piece of mind. Doing the exact same process each day at the exact same times seems to help greatly with good sleep. I’ve found that a little music helps set the mood, but also entertain me. I do very poorly when doing repetitious actions, so I need some mental variation. Luckily, we had an extra iPod Touch, so we set it up to play Pandora to stream baby music each night. We have three stations – “Lullabies”, “Lullabies and Soundscapes”, and “Sesame Street”… and keep the iTouch right next to the feeding chair so you can reach out and control it with your off hand. You can also use the awesome “Total Baby” app to track weight, feeding, and dirty diapers.

#9 – iPod Touch streaming Pandora “nursery rhymes”

Speaking of diapers, we’ve found that a cold wet wipe in the middle of the night is the single best “baby alarm” trigger. Blood-curdling screams result. Our friend Paul got us a wipe warmer, which heats the moistened cleaning towels to body heat. The baby doesn’t even notice most of the time. Awesome!

#8 – Wipes Warmer

Temperature is quite important – babies aren’t quite as fragile as most people think, but they are very sensitive to heat and cold. You especially want to avoid boiling them. This floating thermometer works very well – it beeps when the water is too hot or cold.

#7 – Bath Thermometer

Some people breastfeed, some use only formula. Likely, you’ll do both. And likely, you’ll use reusable bottles to do both. Washing and cleaning these bottles is very repetitive and time consuming, but these three tools make them much easier. Much easier!

#6 – Bottle Drying Rack and microwave bin and dishwasher basket and bottle warmer

To switch gears a bit, we’ve found that mental stimulation seems to really cheer up the baby and keep them occupied. We’ve found this Baby Gym to be perfect for the half hour before bath time. It’s colorful, has a lot of moving pieces, and plays music. An added bonus is that it seems to entertain the dogs as well.

#5 – Baby Gym

When we have the baby downstairs during the day, it’s great to put the baby in this swing. It both rocks, and has a mobile that twirls and our son loves to stare at. As an added bonus, you can tilt the seat up into a sitting position, or down to a sleeping position. Great for getting a few hours free while still having him close enough to keep an eye on.

#4 – Baby Swing

The other best tool we’ve found to keep an eye on the baby (especially at night) is to use a video monitor with an IR light. This one works perfectly, and has extra IR lights so that you can see clearly at night – it also has great audio pickup. With an extra cable, it easily plugs into a television set for prime HD baby-watching goodness.

#3 – Baby Video Monitor and wire

Speaking of taking video and pictures, I’ve noticed that our picture taking has increased about 100-fold. The primary set back to taking more great pictures is downloading them off of memory sticks and posting them online. This EyeFi card is excellent at automatically offloading the pictures from your digital camera and uploading them to a laptop or website like Flickr. I use the Pro card, as it supports about 500 pictures in full RAW resolution (needed for the highest resolution images and work in great photo programs like Aperture).

#2 – EyeFi Pro

If you’re up for some serious baby picture-capturing, I think the Nokia D90 is the best combination of capabilities for the cost, and has resulted in some excellent pictures – and reignited my love of photography. Rather than using the lens that usually comes with the camera, I’d recommend getting the bare body and this fixed lens (which works better in low light indoor photo situations). An added bonus is that it integrates very well with the EyeFi Pro card found under #2 (make sure you get the Pro as you want to be able to use RAW images that the D90 supports).

#1 – Nikon D90 Camera and fixed lens

In conclusion, we’ve been very fortunate to have great friends and family that have supported us during our baby-rearing process. We are incredibly loved, and have a wonderful son that we really enjoy. We hope that some of these finds will also work great for you or the expecting nerd in your life!

People who looked at this item also looked at…

• Chumby Advanced Tricks
• Government Mobile Applications
• Speed Listening
• Wine Making!
• About Jay

Related items

• Speed Listening
• JavaScript HTML5 Image Caching
• Government Mobile Applications
• Building applications for Tysons Corner
• Chumby Advanced Tricks

What Inspired Me

Check out the video that got me interested in writing a game library:

Isogenic allows millions of map tiles to render very quickly by drawing onto an HTML5 Canvas tag, and allows both 2d top-down and side-scrolling games.  The great thing is that it renders incredibly fast – 60 frames per second even with a large amount of data.  You can put images on top and have them animated with incredibly complex interactions.  Wonderful stuff, and you can still sign up for the beta.

And here’s an image of it:

As I started working on this, the Isogenic Engine code wasn’t available, so I looked around for similar tools. John Graham has a 2D Tile Engine that uses HTML5 Canvas that he’s using to teach some advanced JavaScript concepts. Very cool, thought it’s nowhere near as advanced as the Isogenic Engine (but great to learn with if you go line by line!).  Here’s a link to his demo, and source code.  All the code that I will use in the rest of this article series is based on this TileEngine project – John was nice enough to give me permission to build upon his code and post it online.  I’m using this as a hold-over until I can work on the Isogenic engine, and have already learned some useful concepts and JavaScript efficiencies.

The TileEngine Painter

I’ve posted all the source code (zip and GitHub) and a working example for this here.  It works both on iPad, iPhone, and mostly well on Android (rendering works well, but some of the events are a bit off).

In order to demonstrate the map tiles, we’re using a free/open-source spritesheet.  This makes the images look quite “8-bit”, but if you make your own map tiles or use physical map tiles like those from Google Maps), you can get much better looking graphics. There are many techniques to speed up web sites and apps, though I won’t go into them here – take my HTML5 class if you’re really interested – and the one we’ll focus on is sprites.  Loading many images using the web is very inefficient, as there’s an entire HTTP round-trip request for each.  It’s much more efficient to group many small images into one larger image (called a spritesheet in the video game world).  Here’s the spritesheet we use for the base image (it’s a transparent PNG, so can render on top of other images):

The tiles.png spritesheet is broken up into many smaller sprites (each 32×32 pixels), so that if we want to show a piece of green grass in the top left corner (map position 0), we can just draw tile #71, and the JavaScript grabs the correct sub-piece of the image and draws it in the right place.

Here’s what a starting map looks like based on a pre-formatted array in the game.js code:

I’ve modified John Graham’s code so that we can have multiple layers of images that all can be drawn on top of each other for more complex world building.

To draw your own maps, click (or touch on an iPad) the paint layer box in the bottom left, and the drawing palette will expand).  Select the layer you want to draw on, then touch the tile you want then paint it onto the map.  You can have many different layers – though I’ve found that on iPads, you hit the memory limit for a page after about 5 layers.  The great part is that it’s all written in JSON, so you can sync your changes up to a server and with other players (though that’s not built yet).

Some of the neat changes I added to this are:

• A “dirty bit” = a boolean that records if the tiles have been edited or not, this way only the canvas needs to be redrawn if there are any changes, not on each game loop
• Multiple layers, so you can have many layers and spritesheet images associated with each
• A “painter.js” object that lets you paint and change the data model of objects that are associated with each tile
• Some iPad and iPhone specific CSS and META tags that allow for mousepress and mouse drag events on the iOS devices

Here’s the Game Loop that one would use to build a game into – notice that it’s constantly running at 2fps (it can be much faster), and redraws the

The current version doesn’t yet save the maps you draw back to JSON, but that’s working in version 2 (which I’ll post about soon)!

People who looked at this item also looked at…

• HTML5 Map Tile JavaScript Game Engine
• StarPad JavaScript Star viewer
• Building applications for Tysons Corner
• Top 10 Baby products for nerd parents

Related items

• HTML5 Databases + Canvas
• 3d iPhone web apps
• iPhone Geotags
• StarPad JavaScript Star viewer
• Stellar Database

Categories of Mobile Apps

Mobile applications provide huge opportunities and some risks for the developers via common middleware, GUI, tools for downloading and reading blogs, and web connectivity. There are four major categories of applications that developers frequently refer to. From a technical point of view, we differentiate mobile applications by the runtime environment in which they are executed:

• Native platform and OS such as iOS, Android, Symbian, Windows Mobile, and BlackBerry. These applications are built or compiled using a tailored programming workflow process through a tool like Visual Studio or Apple’s Xcode. These will be referred to as native apps.
• Mobile web/browser runtime environment such as Webkit, Mozilla/Firefox, Opera Mini, and RIM. These will be referred to as mobile web apps.
• Native applications that incorporate large sections of mobile web/browser runtime environments in them. These will be referred to as hybrid apps.
• Other managed platforms and virtual machines such as Java/Java to Mobile Enterprise (J2ME) Flash Lite, and Silverlight. These will be referred to as Rich Internet Applications (RIA). These are sometimes referred to as native, rich client apps.

Mobile applications have evolved to the point that they now provide developers with ample mature tools, which enable developers to rapidly build and deploy new apps. Open source tools are the primary enabler of these native development environments. Native apps are different from mobile web apps, which require web connectivity and are sometimes characterized by latencies due to page load times. RIAs use an interpreter platform and are frequently resource intensive, draining the mobile device’s battery or performing poorly.

Each of these app categories have different requirements for integrating, deploying, and managing them within an enterprise. There are specific tools to aid in this, which differ by platform, and are frequently called middleware.

In terms of development quality, a skilled developer can almost always make a more efficient mobile app that provides a better experience with fewer errors that any of the other categories, though these take more time to build. An emerging category of hybrid apps incorporates some native application logic along with mobile web browsing, allowing for much of the development to be done with HTML, a widely known environment.

Handling offline caching

In the HTML5 Database and Canvas article on this site, I delve into how to use the canvas to load images from the web, then save them into the local SqlLite database that is part of HTML5′s offline storage capability. Long story short: you can only save strings/integers into offline storage, so first we convert an image into a base64-encoded string, then save that.  Kinda tricky… and not very efficient, but it works.  Other options are to use the HTML5 Manifest File to specify exactly what files to cache, but it works intermittently and isn’t good at allowing you to dynamically decide which images you want to cache. Also, support is a little varied on each browser…. so we need another option.

A hard part about offline caching of images into base64 strings is that it’s a pretty inefficient process. It works, and is pretty cool… but can be slow with larger files.  Also, as every database interaction is asymmetric (meaning that if you run a query, you don’t know how long it might take to complete), it can sometimes be a few seconds before a larger image is saved or loaded.  This requires some pretty fancy JavaScript.  So, without further ado, I’ve posted some pretty fancy JavaScript for this caching library at: https://github.com/jaycrossler/JavaScript-Cash

After adding the cash.js library to your code and initializing it when the page loads, it’s as simple as calling:

var imgtarget = document.getElementById('myimage');

Cash.loadToImg(file, imgtarget, true);

This will first check the cache to see if the image is saved in the local database, and if so it will pull the image from there.  Otherwise, it will pull the image from the web, write it to a canvas tag, then save that data to the database.  This way, you can programmatically save a large amount of images in the background, then call them later when bandwidth is limited (or if you want to reduce impact on the server).

A big issue still to be addressed is that on most iOS devices (iPhone and iPad), you have limited resources available.  After using 5mb of offline database, the user will be prompted to ask if they will allow more to be saved.  Also, if any single Mobile Safari tab uses more than 10mb of RAM from a programmatic call, it will automatically hard-crash the browser through an exception.  This is painful, and I haven’t found a way to see how much RAM you’re using… so the next version will keep an internal estimate of how much RAM is being used.  Any time you pull a 1mb image, it looks like you’re using 1.5mb of RAM.  Converting that to a <canvas> tag, then writing it to a string and sending that to the database seems to take another 1mb of RAM.  So, you’re looking at only really being able to play with 4mb of images this way at any one time.  I’ll do a more detailed analysis for the next article.

This is optimized for working on mobile devices, such as iPhones, iPads, and Android phones.  I’ve tested it on each, though there is still a bit of fine-tuning required.

I’ll be posting a follow-on article showing how best to use it within a map-based game engine, so stay tuned!

People who looked at this item also looked at…

• StarPad JavaScript Star viewer
• Government Mobile Applications
• Updated FlickrProxy
• Chumby Advanced Tricks
• Star Wars Chess

Related items

• StarPad JavaScript Star viewer
• HTML5 Map Tile JavaScript Game Engine, Part 1
• Stellar Database
• Building applications for Tysons Corner
• Chumby Advanced Tricks

A year ago, I realized that I have many more audio books and podcasts to listen to than I could ever consume.  I needed a new way to consume audio faster, so started looking into way to listen differently. I tried a few apps that let you take an mp3 file and double the playback speed, but most of these were too cumbersome or made the audio sound ‘chipmunky’ as the amplitude wasn’t shifted properly along with the frequency.

I finally found that the best fast-audio experience was built into iPhones and iPod touches using the standard iPod playback. When listening to a file that is marked as a podcast or audio book, a ‘speed enhance’ icon is shown. This can be played at single, 1.5x, or double speed.  Note that the icon shows “.5x”, but it really means 1.5x. When I first listened to spoken words at double speed, I could barely understand what was going on.  I needed to train my ear to get to this level.

Long story short, I now listen to audio books and podcasts at double- to triple- speed, and can fully understand and comprehend what I hear.  In fact, to me it sounds normal – even music played at double speed is starting to sound good and distinct.  I think this is a skill that can be trained, and so I’ll walk through some suggested steps.

It took two months to get comfortable with listening to audio at double speed. I found that the key was to listen to podcasts that had varying and alternating male and female voices. As I am a tech enthusiast, I listened to 40 episodes of Buzz Out Loud, which is a podcast that usually features three semi-random hosts, male and female.  This provided interesting source material, and enough variation to train my ear.  Also, I could start and stop at almost any time without losing an ongoing narrative (as material covered is usually discrete stories).

I started by listening to a podcast at 1.5x speed for a few minutes, then switching back to 1x speed once I started feeling uncomfortable.  Each new listening session, I pushed a little bit longer.  After two weeks, I was comfortably listening to all podcasts at 1.5x speed.  There were some weird issues due to audio codecs, where some music played at this speed sounded choppy… But still consumable.

Next, I repeated the process to get up to double speed… But this took much longer.  It was too convenient to stay at 1.5x speed, as going faster was hard to comprehend.  I needed a challenge – so decided that I would spend 1 month to try to listed to the Wheel of Times audio books (12 books, 10k+ pages, 400 hours of audio).  Oof.  And, I almost made it… (got through 11 books in 30 days, then just needed a mental break). I averaged 10 hours of audio per day (or 5 actual hours when played at 200%). These books were ideal as they alternated male and female speakers, who each used multiple different voices in their storytelling.  As a note, you can usually find free audio books in either cd-form or mp3 at your locally library… which is important when 11 books would cost $300.

I now listen to everything at double speed, which feels completely natural.  Sometimes, for audio book readers that I’m familiar with, I first speed the audio up 50% using MP3-Trimmer, then listen at double-speed for a combined 300% playback speed… Though this might be a bit neurotic.

My favorite podcasts are:

• Tech News Today (I like it much better than any of the other TWIT shows, and the dynamic of Tom Merritt is great to listen to)
• Buzz out Loud
• Onion News Network
• Sword and Laser
• This Week In Tech
• Tips from the Top Floor – Photography

People who looked at this item also looked at…

• StarPad JavaScript Star viewer
• Chumby Advanced Tricks
• About Jay
• Government Mobile Applications
• Building applications for Tysons Corner

Related items

• Top 10 Baby products for nerd parents
• JavaScript HTML5 Image Caching
• Government Mobile Applications
• Building applications for Tysons Corner
• Chumby Advanced Tricks

The article I wrote is posted on our page here, and is one of the 10 articles featured in the magazine.  Cool stuff!  I’ve reposted the article below for posterity:

SOCIAL NETWORKING TECHNOLOGY: FROM CAVE DRAWINGS TO TWITTER

By Jay Crossler

SUMMARY: People are natural collaborators. Organizations that are familiar with the latest social networking tools can reap the fullest benefits of collaboration.

The Oldest Technology

Social networking is not new. You might even consider cave drawings to be among the first social networking tools. Mammals all use social networks to survive. The only thing new about social networking is the set of tools we’re using to capture and augment these skills. Everyone who has told stories, dated, dealt with customers, or worked on a team has used social networking “soft skills.” It is no surprise that tools such as YouTube (storytelling), Match.com (dating), LinkedIn (career networking), and Facebook (community building) have evolved to augment our communication tasks.

Tools Ready to Use

With the emergence of these new tools to mediate ancient forms of communication, and with increasing economic incentives to allow for effective collaboration without physical collocation, it’s no surprise that businesses are clamoring to find the best ways to take advantage of these tools. However, despite the fact that government agencies and businesses recognize the power of social networking tools to increase productivity, it can be difficult taking advantage of them.

The variety of tools that are available, the differences in the capabilities supported by these tools, and the murky and often dynamic waters surrounding issues like data ownership, security, and typical user base can make it difficult for people without expertise in this domain to develop an effective social networking strategy. In an effort to address these issues, MITRE focuses on bringing together expertise from a variety of areas, including individuals with social media development expertise, organizational change management experts, information assurance teams, and others. Bringing these experts together from the outset makes it much easier to ensure that these concerns are addressed.

MITRE is frequently asked by sponsors: “Help us build sites that let our employees better collaborate.” When the sponsors describe what capabilities they want these sites to have, they describe functions commonly found on Facebook or YouTube. They’re usually shocked when we then suggest that they use what are generally thought of as recreational sites. But rather than reinventing the wheel, we need to encourage sponsors to make use of what’s authorized, available, popular, and evolving.

Another challenge that many organizations face is to understand the way that the corporate culture may need to change in order to really capitalize on the use of these tools. One common misconception is that allowing employee access to external social networks is always a bad practice. In reality, allowing employees access to both their corporate internal as well as external professional and social contacts can provide a very valuable source of work-relevant information. The main goal should not be to find the most effective ways to limit access, but rather to train the staff about what uses of social networking tools are appropriate in the workplace.

Networking 2.0

For example, when I attend large meetings, I’m often asked questions such as, “What technologies should America invest in for the future of health care?” I immediately post the question to my Twitter and Facebook accounts. By the time I’ve finished exchanging pleasantries with my fellow attendees, I usually have 10–20 social network responses to the question from MITRE employees, my old college buddies, or even people that I’ve never met who search for words like “health care.” Some of the ideas are exceptionally creative, beyond anything I would suggest. Social networking tools allow you to capitalize not only on an individual’s expertise, but a network’s expertise.

Wikis—Web sites that allow users to add and update content on the site—take advantage of this “network expertise” to build vast and reliable data repositories. The U.S. Army has found that it takes too long to have subject matter experts alone write their training manuals. So the Army is experimenting with “wikifying” the manuals, inviting the military community to contribute their knowledge and to review the contributions of others.

INSIDE VIEW “When you’re looking someone in the face,” says Jay Crossler, “you can make a lot of preconceptions that get in the way of really understanding that person.” Crossler had a very early experience in how connecting with people online can short-circuit preconceptions. “As a kid, I was stationed with my family in South Korea. I was fooling around with programming, and I wrote a multi-modem dial-up script to help the service men connect to the Internet. I listed my name and email address, but not my age, in the script. People were so impressed with the script that the local computer club elected me sight unseen as their president. When they called me up to tell me, I shouted, ‘But I’m just a kid!’”

Managing Complexity

MITRE is taking a two-pronged approach to research in the fast-moving world of social networking. First, MITRE human-computer interface experts, graphic designers, software developers, usability researchers, knowledge management teams, and organizational change management gurus work with sponsors to identify, modify, and, in some cases, develop tools that fit with the organization’s information sharing and social networking needs.

A shining example of this effort is the Tactical Ground Reporting tool, prototyped in collaboration with DARPA for use by warfighters in the field. This tool can be classified as a “mashup,” integrating multiple data sources into a single, straightforward user interface. In this case, the tool brings together mapping tools with data sharing and collaboration tools to allow soldiers in the field to track, update, and rapidly share information about, for example, the location of potential improvised explosive devices or other items of interest on common patrol routes.

Second, MITRE uses its own internal corporate network as a testbed for social networking tools, examining not only how they are built, but what features are most likely to be adopted and what design, interface, or functionality elements have the largest impact on user adoption. Recently, MITRE engineers have developed and tested everything from electronic phonebooks, wikis, and chat clients to Facebook-like social networking tools and applications that can be used on mobile devices like cell phones.

There is also ongoing work on mechanisms designed to help improve the value extracted from shared information. There is value to be found in conducting public discourse, recording it, and linking it all together. The hard part is sifting through it all. When you have a hundred databases from different agencies linked together, a federated search sometimes returns thousands of results. Prioritizing and ranking results based on trust is challenging.

MITRE is exploring the use of social networking methods to deal with this complexity. We’re helping to build systems where humans collaborate in organizing the information, whether by tagging relationships, rating the reliability of data sources, or ranking the pedigree of various classification methods. The same algorithms that Amazon uses to recommend books you might like can be used to point analysts to the data they need, allowing them to more efficiently and effectively identify information that is crucial to mission success.

By understanding and employing social networking tools, organizations can tap the full potential in the ancient human ability to collaborate.

People who looked at this item also looked at…

• Chumby Advanced Tricks
• About Jay
• Government Mobile Applications
• Building applications for Tysons Corner
• Speed Listening

Related items

• JavaScript HTML5 Image Caching
• Building applications for Tysons Corner
• StarPad JavaScript Star viewer
• Stellar Database
• Top 10 Baby products for nerd parents

While most of the details haven’t been publicly released, we’ve been discussing the strategy for government programs to utilize mobile devices and applications.  We’ll be releasing a lot more details later, but it’s cool that some of our successes are being highlighted.

People who looked at this item also looked at…

• StarPad JavaScript Star viewer
• Building applications for Tysons Corner
• About Jay
• Chumby Advanced Tricks
• Top 10 Baby products for nerd parents

Related items

• Stellar Database
• Top 10 Baby products for nerd parents
• HTML5 Map Tile JavaScript Game Engine, Part 1
• Speed Listening
• Building applications for Tysons Corner

The thinking is that a better way to get information to users would be to build one or more information services that will assist – either iPhone/Droid apps, or tailored web sites.  If you could have any piece of conceivable information, what would be most useful?

This would include both the Mall as well as the surrounding area and all of the new Metro stops. We’ll be building a proposal and prototype to help out the local government. What do you think we should have in/on it?

For the Mall:

1. Map of parking area with updates on available parking spots.
2. Means to mark your spot on the map and some way to trace your route back to your car.
3. Layout of mall. You are here identification.
4. Recommendations for non-busy times.
5. Senior specials. Maybe special area for Seniors: exercise suggestions; food suggestion; matinee movie suggestions;
6. Movie listings.
7. Special sales or activities in mall stores. Coupons would be good. A way to hold your iPhone to a store scanner for them to read your coupon. Maybe a way to have your name and phone number on your phone be scanned in by stores or sales people for drawings like for a new car or whatever.
8. Holiday or special activities or presentations.
9. Food Court identification and other eating facilities. Ratings on cleanliness. “Eat This Not That” recommendations (maybe tie-in to app for that.) Vegan or Vegetarian suggestions.
10. Restaurant reservation system.
11. Restroom locations. Elevator or handicap identification.
12. Mall-walker distance and route suggestions for exercise purposes.
13. Search capability for items for sale with stores that have availability. For instance “shoes” or “fondue pot”
14. Feedback capability to make suggestions to mall managers and/or stores.

For Tysons:

1. Traffic patterns and route planning
2. Augmented Reality of bus stops, traffic directions, points of interest
3. Metro delays
4. Metro and construction status, dollars spent, current plans, expected benefits
5. Events in the area
6. Highlight businesses to sponsor key companies in the area that are supporting
7. Coupons or store bonuses for reporting suggestions or road improvements (light out, pot hole, graffiti, car accident, etc)
8. Carpooling recommendations

I’d love more requirements or prioritization of what would be best to build!  What would you find useful in the most congested/largest Mall area of the country?

People who looked at this item also looked at…

• About Jay
• iPhone Geotags
• Government Mobile Applications
• Chumby Advanced Tricks
• Crossler.com

Related items

• HTML5 Databases + Canvas
• 3d iPhone web apps
• iPhone Geotags
• Stellar Database
• HTML5 Map Tile JavaScript Game Engine, Part 1

(built on previous Chumby iRemote post here)

Overview
This past month, I extended the web server on my older-style Chumby to add a lot of functionality to my house. For a while, I’ve wanted to automate a number of my home systems – X10 to control our home lights (specifically the Living Room lights), the Chumby to play music with, and web cameras to watch our dogs during the day. As the new Chumby just came out, I thought it would be useful to build all of the control into the Chumby device, so that others could also try the same thing.

I also build a feedback system that would try to monitor the amount of times our dogs jumped and barked at cars, then change music and turn on/off lights to find the combination that calmed them the most. Unfortunately, I found that there is no magic configuration – rather the dogs seem to relax whenever the lights and music change (possibly because they feel that someone is home). Either way, it was a cool experiment that I learned a lot from. It is a bit “fragile”, meaning that there’s a good amount of custom configuration that you would need to use to reuse everything. Nonetheless, I’m posting all code and configuration samples here in case people want to set parts up themselves. The X10 webpage, for example, is pretty useful even if it is the only piece loaded.

Details
I call this marvelous contraption the “Puppy Ubiquitous Pacifying Preference Engine” (PUPPE). If you want to be all research, the Technology Goal was to build an automation engine that optimizes environmental support for dogs left home alone. The Research question I set to achieve was: Can an automatic feedback engine be used to optimize relaxation for dogs by controlling home automation electronics? I was partially able to achieve this goal, though in a way I completely didn’t plan for. Rather than find an optimal configuration, I found that the more I randomly changed the lights and music throughout the day, the more relaxed our dogs seemed to behave.

The tools I used for this were:

• X10 Wall Light Switch
• X10 Application Switch
• X10 Home Automation software on Windows XP (old laptop LAP1)
  • X10 Controller software listening on TCP port 6003
• Mobiscope Desktop Webcam controller on Windows XP (old laptop LAP2)
  • copSSH – ssh server for secure remote connections
  • ipsecCmd and IP Security Policies to filter IP traffic
• Two cheap USB webcams
• Mobiscope web site for hosting video
• Weather Web Service for determining sunset time
• Chumby running ChumbyOS Linux (CHUMBY3)

Client devices:

• User Laptops (LAP4 and LAP5)
• iPhones (PHONE6 and PHONE7)

There were a number of moving pieces to this configuration, and each piece took a while to determine the best approach to implement. I’ll describe the solutions and tricks I came up with below. Many people probably won’t have two extra laptops laying around, so the configuration will likely change depending on circumstance. I spent a good portion of overall effort intentionally trying out different approaches and security option, so there are many other ways of having the same effect. The X10 Commander interface is shown below:

Technical Architecture

The picture above shows the logical architecture I came up with. All the software actually ran on the Chumby (except the Mobiscope viewing page that is hosted on that company’s web server). I firmly believe that as systems become more complex (some people call this a Service Oriented Architecture – which I’ve studied in depth, but don’t want to go into here), it’s important to build very simple interfaces. I implemented three main types of API service interfaces, each very simple to work with. I call these “ramps” or “loose couplers.”

Loose Couplers:
HTTP GET-based web service. In the simplest configuration, a web service is a web page that a machine returns when it receives a certain input. The Chumby has a CGI-based web server that can be used to run simple sh shell scripts. We pass in variables through an HTTP querystring (the part following a ? in a URL). This way, when an event.cgi?setVolume0 is called, the cgi file shell command executes a command to mute the radio. We use x10.cgi to listen for light-switch control messages, event.cgi for Chumby-specific events, and cameras.cgi for commands to control the web cameras.

The Chumby also can act as a hosting web server, using an index.cgi page that points to all of the other commands. The interface looks like this:

And the hosting code looks like (the launch javascript is declared in the full file, see attached code):

SSH-based camera control service. Secure Shell or SSH is a network protocol that allows data to be exchanged using a secure channel between two networked devices (as described in RFC 4252). Most linux or unix-based machines (including the Chumby) have an ssh client or an ssh server built in. As we want to control services on an Windows XP machine, we needed to add an ssh server, so I chose copSSH after testing multiple other options. By using IP Security policies, we can add a firewall filtering policy to the machine from the command line with a batch file (Cam-Block.bat) that runs `ipseccmd –w REG –p “BlockMobiscope” –x`, where BlockMobiscope is a windows IP filtering policy as shown below:

To make remote triggering as simple as possible, we want to enable PKI key exchange on both machines. This allows a single shell command `ssh UserName@192.168.2.3 ‘./Cam-Block.bat’` run on the Chumby to securely turn on or off traffic from USB cameras being sent to the Mobiscope web server. The home router is configured to always map 192.168.2.3 to the camera server (LAP2), which saves a lot of effort when machines don’t properly identify their hostnames.

One of the most painful steps is setting up the SSH server to run without entering a password at every instance. Building this PKI key-exchange process uses ssh-keygen command to generate a client and server key. Because the Chumby does not have ssh-keygen installed, we need to build the ssh keys on another machine and remotely configure both the chumby and LAP2 server with these keys. Once we do this, we can be reasonable assured that only the Chumby can interact with the XP laptop (LAP2). Because this machine controls transferring video from our USB cameras out to the web, we want the most amount of security around this interface.

TCP-based network injection service. By using the X10 Active Home software with the X10 Commander program, iPhones can send TCP messages to a laptop to turn X10 devices on and off. Rather than using the iPhone client, we can spoof TCP messages to emulate the same commands that the client would send. By using WireShark, I found that the TCP commands are simple messages sent on port 6003:

Using NetCat ‘nc’ – (my new favorite linux command!), these messages can easily be replicated using the shell command: echo ‘DEVICE~sendplc~”C4 ON”‘ | nc 192.168.2.4 6003 (this is to the LAP1 Home Server). This is not very secure, but is based on inherent security limitations of the X10 Commander software. Given time, I might rewrite a more secure X10 controller. As only the lights are controlled from this server, I found that was a worthwhile privacy tradeoff.
Experimentation

Dog owners frequently ask “What are my dogs doing while I’m at work?” My wife specifically wanted to watch our dogs while she was at work (and her company blocked the firewall connection). To give her this capability of watching our dogs that are blocked off in the kitchen each day, I set up a pair of USB cameras on an old laptop and purchased the $20 Mobiscope software that is iPhone compatible. She is able to watch her dogs anytime she wishes on her iPhone.

After observing our dogs for a few days, we noticed that they would become more and more agitated throughout the day, and bark at cars and pedestrians walking outside our window. Some days they were more relaxed, and some days they were more agitated. Every day we played different radio stations, and surmised that different music at different times would help calm them. Also, we noticed that with shorter winter days, the sunlight dimming early in the evening seemed to agitate them more. We surmised that if we could modulate lighting conditions along with music, we could help minimize the amount of times they got up to bark out the window.

The experimentation had two phases. During the first phase, I used the two USB cameras to record the dogs in time-stopped video (3 frames/sec). By trying a number of algorithms, I determined that a good way to rate the number of “agitations” was to identify an active area of the camera view and to count the amount of pixel change over a period of a second. As shown in the picture above, if more than 84% of all pixels in the active area changed in a second (out of a max of 300% as there are 3 frames x 100%), then a recording is triggered and an “agitation” is recorded. Due to varying lighting conditions, this number was not optimal in every case – and recommendations are not to use the Mobiscope to do this process in the future.

Average # of agitations/hour at time-of-day

The # of agitations/hour was then used to build an algorithm to remotely turn on and off lights and to change radio stations in the kitchen. Unfortunately, there was no reliable way to detect agitations as they occurred. The Mobiscope web page hosted only cycling images and passed recording #s through javascript. A few attempts to “Screen scrape” the number of recordings only worked intermittently. I used a greasemonkey script that would read the data, but had many issues with reliability. (As a note, I just realized yesterday that each recording of an agitation produced a new data file in a directory – and that directory could be watched for updates to trigger the algorithm. This would be useful in follow on work).

I worked through 5 algorithms that were all sh shell scripts fed through the web page and greasemonkey script. This proved problematic, as the script never ran concurrently throughout the day. Greasemonkey just wasn’t robust enough to handle web errors or dropped connections from the Mobiscope server. As these were working locally inside my home intranet, I didn’t have a reliably secure method to tweak and monitor these while I was out of the house (and whenever I was in the house, the dogs’ behavior would change dramatically).

When the algorithms did work, it became quickly apparent that every change was a “good” one. Any time there was an agitation, if the radio was changed or a light level was adjusted, the dogs immediately calmed down for a period. It didn’t matter which radio station or which light level was set. Any change seemed to reduce agitations. The algorithm I now use just rotates radio stations and light levels randomly, without any inputs. On average, it seems to have reduced # of agitations by 45% (though I haven’t yet had enough testing to ensure it is statistically accurate or will remain lower).
Privacy Engine

In order to use the system well, we wanted to add two extra capabilities:
1) When either my wife or I come home, turn off the web cams and radio, and turn on the kitchen lights
2) As a backup, turn off any recording at sunset (in case the first doesn’t trigger)

To implement the first capability, we need a way to detect when either of us comes home. I initially tried using an X10 motion sensor in the door way, but it was quite cheap and would sometimes trigger when there was direct sunlight on it, and frequently not trigger when people walked by too quickly.

I’ve noticed through watching Wireshark that when an iPhone connects to a wifi network, it sends out a few IGMP/Multicast DNS packets to 224.0.0.251 (local multicast to all machines, as specified in RFC 3171). By listening for this message, I have the Chumby look for the correct identifiers and send out the “turn cameras off”, “mute radios”, and “turn lights on” commands.

I would have liked to detect a method for turning the cameras on when no one was home (as we frequently forgot to do so in the morning), but couldn’t find a reliable method.

To implement the second capability of always turning cameras off at sunset, I had a script that pinged a web service daily and asked for the sunset time of the current locale. The below script illustrates this method (but condenses some of the logic for readability).

(Note: That should read “sunset” not “sunrise” in the web service request above… otherwise things get a little wonky.)

Conclusion

This was a fun project that had a lot of moving pieces. I built some useful functions that we still use daily. The light and radio controls are very reusable, and I will be releasing all of the source code for others to do so. I was able to partially prove out that modifying the environment modifies our dog behavior. More importantly, I gave my wife tools to feel more attached to her dogs throughout the day (and justify my spending money on technical toys).

The code is here, please download – released fully creative commons/open source (BY 3.0 license).

People who looked at this item also looked at…

• Chumby iRemote
• Crossler.com
• About Jay
• Government Mobile Applications
• StarPad JavaScript Star viewer

Related items

• 3d iPhone web apps
• Chumby iRemote
• StarPad JavaScript Star viewer
• Stellar Database
• HTML5 Map Tile JavaScript Game Engine, Part 1