In trying to build a good replacement for other numerical processing applications, we’ve needed to benchmark the performance of cloudlab versus other places in which JavaScript can be run to process numbers …

- Me, over at the cloudlab.io blog

For those who don’t know, cloudlab.io is an online numerical processing suite akin to Matlab or Octave or Sage that utilizes JSON and Javascript and the POWER OF THE CLOUD!

Unfortunately, the reason we’re all stuck on this dumb rock is that capital flows mainly in one direction these days: up towards those with the majority of it. The reason the Occupy X movement has been gaining ground in the United States is that with 10+% unemployment (more for other elements of society), crippling debt and the incredulous sums paid out to financial institutions for acting illegally, the poor are becoming poorer and the richer are becoming richer. Besides the degradation in workers rights, the influence of money in the political process and the ever growing totalitarian police state, people are waking up to the fact they are getting screwed over from cradle to the grave.

It’s not as bad here in Australia. We enjoy a fairly robust political system (not to be confused with the current policies and leadership of those currently in government) and workers rights are fairly good (thanks to the abolition of Work Choices). Unionism is on the decline, the same unionism that gave us the rights we have at work now. All in all, we’ve got it pretty good, but isn’t it better to strive for something even better?

Download

I’m planning on turning-out to the Occupy Brisbane protest tomorrow to gauge the feelings of those who want to make things better (hopefully a valid supposition). As such, I’ve thrown together a little primer on anarchism (click the picture to download) that tries to get tongues wagging with some general information and some questions that should spur discussion. I’m no ideologue, just an engineer with some hopes and some ideas, so don’t think this is the be-all and end-all of what anarchism is about. Comments would be very welcome and what’s the harm in ideas?

The testing and monitoring of elite athletes in their natural training environment is becoming an area of interest to the sporting community. Specialised equipment is cumbersome and influences the training and analysis regimens athletes undertake to improve their performance. Ubiquitous and off-the-shelf versatile smartphones with advanced sensing capabilities can be applied to sports activity monitoring, providing a cost-effective means of widespread performance analysis. This paper briefly outlines the case for using these smartphones in sports monitoring applications, presents a model to collect data generated by these devices and presents the results of real-world usage when applied to cricket.

Currently, we have a (mostly) working implementation of the core library sans 3D-rendering subsystem components. We can code, deploy and run these processing sketches on all of the iOS devices (iOS 3.2+). However, there are a few issues we’re wrangling with right now and it’s because of the toolchain which makes this whole Processing sketch to App conversion. To understand the problems involved, let’s have a look at how we do it. Read more here.

.redact {
  background-color: black;
  color: black;
}

<p>My name is Tristan and my number is <span class="redact">###-####</span>.</p>

My name is Tristan and my number is ###-####.

Obviously you wouldn’t really use CSS to redact information, but it serves as a clue to the reader that this information is hidden for a reason.

Thanks to some pivoting, we’ve been working on something pretty damn cool: Processing for iOS. What it is is a set of libraries and tools which allow the processing user/developer to deploy native apps into the iOS ecosystem. We’re also working on some cool extras that will make the non-coding parts of the development process easier.

The core processing implementation we are developing is a clean-room one developed from the available documentation, and while it makes things kinda hard doing it this way it is necessary in maintaining our obligations to the open source community. It’s not going to be a free product, however we are exploring ideas on pricing taking into account the differences between hobbyists and commercial enterprises. We will be contributing back to the relevant open-source tools we do use and modify in accordance with the various open source licences.

Anyway, have a look at the video in our announcement. If you’re in the San Francisco Bay Area or at WWDC this week and you want to meet up and talk about Processing for iOS, or what Seditious Technologies can do for you (we also do client work), just reply here, send me an email or tweet and I’ll get back to you ASAP.

The provided socket interface to FlightGear is pretty neat, and I could definitely see creating a native app on the horizon if I thought there was any interest or money in it. Being able to control your autopilot, flight controls and aircraft systems through an iOS device would be pretty sweet.

You can grab the solution here (MIT Licence) and Accelerometer-Simulator here (it’s free). Read the README.txt file for more information on how to use it.

Image courtesy of Ars Technica

This year the promotional hint that Apple dropped was Join us for a preview of the future of iOS and Mac OS X. On the surface it’s saying “hey, we got OS X Lion and we’ll be shipping the next iPhone soon”. While everyone in the digital punditry scene seems to agree on this, I think John Siracusa on the latest Hypercritical (A Dark Age of Objective-C) may be onto something with his Avoiding Copland 2010 thesis.

Basically, his central argument boils down to a software technology crisis: Apple hasn’t got a plan to modernise its software architecture and they’re in for some Heavy Shit ©. He posits that Objective-C, while given a boost in necessity thanks to resource-constrained iOS devices, hasn’t kept track with the wider development world which has transitioned to memory-managed languages like Java, C#, and dynamic languages like Ruby and Javascript. While the language itself has evolved (for example, Blocks), Objective-C for the most part is still a wrapper over C. OS X and iOS still share a common ancestor in NeXTSTEP which was created decades ago, something akin to the lineage of Microsift’s NT kernel.

I have to agree with him and I for one could see Lion as the tail end of OS X. If the message Apple is giving us with WWDCs subtitle is read between the lines, then perhaps we could see an announcement that addresses Siracusa’s concern. Can Apple do away with Objective-C and Cocoa? Assuming Apple wants to sink some serious cash into developing the next leap in operating system architecture (i.e. their Midori) and kill a bunch of developers by transitioning to a totally new non-legacy programming interface, what are their options when it comes to the de-facto programming language?

Apple with learned from many third parties that they can’t rely on others for support. Java is out, thanks to Oracle’s asshattery. C#, while an open ECMA standard, is predominately a Microsoft technology bound to the .NET platform. Sure, they could finagle the language onto a new framework that implements just the standard-defined types, but let’s just agree that C# and .NET were made for each other. For the past few years, Apple has been pouring a bunch of resources into the  LLVM Project. What’s interesting about this toolchain is that you can have multiple front ends and all the features of modern compilers like JIT and position independent code (PIC). Apple could in theory support any language with a LLVM front end.

A language like Objective-C.

In any case, my learning aims for WWDC in June are a bit different from last year. Last year I was a nascent iOS developer looking for a better knowledge of the platform and luckily for me, the majority of sessions were geared towards iOS. This year, I’m looking to improve my web applications knowledge and low-level iOS programming (OpenCL, optimisation strategies etc).

If I’m lucky, I might even pick up an iPad 2 if the exchange rate holds…

Back in December of last year, the guys from Scope TV filmed a segment with me about my research on using smartphones in sport. I basically go over the dumbed-down version of my research and even show a bit of the research software I’ve developed (waiting for peer-reviewed publications to go through before I expound on the details of it).

A big thanks to Roger Chappel for serving as a running prop. You can find the Smart Phone Tech video here at Channel Ten.

MobileLogger [Free]

This app is my favorite offline logging application that has great functionality and a damn fine interface . Compatible with iOS 4, it allows the logging of acceleration, location, heading and audio. Logging formats include CSV, JSON, Golden Cheetah and GPX. Logs can be emailed in the desired format, or you can dump all logs (stored in a SQLite database) and have that emailed to you.

A very interesting facet of the app is the backing web application which presents a unique geographical view of users who’ve chosen to upload their data. Developer Robert Carlson did an outstanding job with the user interface; reviewing logs is a breeze with pertinent metrics like duration, distance and speed. The only faults I can give the app is a lack of gyroscope support using the new CoreMotion framework, and that the Dashboard view looks a little simplistic and underwhelming compared to the polished quality of the rest of the app. Nitpicks really.

MobileLogger is available free on the iTunes App Store and you can grab the Titanium source code (GPLv3) on GitHub.

SensorLogger [Free]

I require realtime sensor data feeds for my research, so when I needed something to fill the gap while my own app was in development, SensorLogger stepped into the breech and gave me what I needed. SensorLogger is much like MobileLogger, but with a more .. utilitarian interface, support for the gyroscope and realtime streaming over UDP sockets. Logs are recorded on the client’s side in CSV format and can be emailed after recording. Also available from the developer is a SensorLogger network listener (Objective-C) and a Quartz Composer plugin.

While data can be streamed, the downside is that there’s no binary streaming mode – data is transmitted in text form and in the clear.  I’ve also found occasional glitching in its storage of log data and transmission of high-frequency multi-channel data (i.e. turning it up to 11).

SensorLogger was developed by Scott Gerring at AmongstBits and is available for free on the iTunes App Store.

Sensor Monitor [Freemium]

Certainly the most comprehensive coverage of iOS sensing, Sensor Monitor by Ko, Young-woo is a hard app to love. The interface seems ad-hoc and consists of UI components dropped into a view and organised with tabs. Another gripe I have is that unlike SensorLogger and MobileLogger, logging in the free version consists of  individual sensor channels dumped into separate files.

Sensor Monitor’s redeeming feature is it’s coverage of the different sensors (location, heading, acceleration, rotation, audio, battery, and touch gestures). While I’ve not upgraded the app (UDP streaming becomes available), I could see this app becoming much more useful for non-techie users if the interface was cleaned-up and getting your data out for multi-sensing sessions wasn’t such a pain.

I can’t really recommend this app for the average user, but the free version is good enough for developers and techies.

xSensor [Free/Paid]

Coming in second last is xSensor (free) and xSensor Pro (USD $9.99) by Crossbow Technology, Inc. This app came out quite a while ago and isn’t quite up to date in terms of sensing capability, but it has a slick, easy-to-use interface that most users can appreciate. Sensing is restricted to accelerometry, location and heading and is limited to some odd sample rates (1/4/16/32 Hz). Files can be logged to CSV format, and the paid Pro version increases the size of logged data.

While the free version of the app is great for just about everyone, asking $9.99 for the pro version is really just gouging the user (I got mine on sale!).

_

Accelerometer-Simulator [Free]

Accelerometer-Simulator (AccSim) was my first experience with using iOS for activity monitoring purposes, and I’ve used this app for a number of different applications aside from my research (see: Processing and the iPhone). For data logging purposes it’s okay, but its real purpose is to give your simulated app real accelerometer data through UIKit’s UIAccelerometer and an XCode #include.

These days AccSim is a bit dated and doesn’t support the new CoreMotion framework or any of the other sensors available on iOS devices, but if you’re just starting out in iOS development and you’d like to get a feel for how an application in this class is designed, or you want to have real acceleration data samples in your app through the simulator, I thoroughly recommend AccSim. From what I see of the other sensor apps on the store, a lot of people have used AccSim too.

AccSim was originally developed by Otto Chrons and was made available for free by Brian Pratt on the iTunes App Store, with the project’s source code (BSD) available on Google Code. You can find additional information about AccSim on its support page.

I had initially written these articles some time ago, waiting for the day I could release the whole library in one swoop. Things have changed and time is at a premium, therefore I’ll be releasing articles every other week or so. The intended audience is not those who already learned from the bigger brother framework, but for those transitioning from other environments (Arduino etc) and want to know a little more about what the .NET Micro Framework has to offer the developer.

Articles

• Collections: “… implement traditional data management structures that can be useful in a variety of situations, allowing easy storage, retrieval and manipulation of data contained within them. We will explore the four main collections within the .NET Micro Framework’s System.Collections namespace: Queues, Stacks, Maps and Lists.“

Note: When you see this icon, you can follow it to MSDN’s documentation.

As a quick proof-of-concept, I decided to see how far I could go in designing an embedded, code-first database that can be used with my Netduino. Enter Mu Database, a simple object-oriented database to help you manage your data. Begin overview-by-example!

The example included with the source is for use with Secret Lab’s Netduino, and also requires MicroLinq. After creating a new Netduino application and importing the required references, define your table’s model with a simple class:

    [Serializable]
    public class Product
    {
        public int Id;
        public string Name;
        public float Cost;

        public Product(int id, string name, float cost)
        {
            this.Id = id;
            this.Name = name;
            this.Cost = cost;
        }

        public override string ToString()
        {
            return "Id:" + this.Id.ToString() + ", Name: " + this.Name + ", Cost: $" + this.Cost;
        }
    }

In MuDB, public fields correspond to table columns. Notice that the class is also marked Serializable. To start the process, create a new instance of MuDB and insert a new table into it by passing the type of our model (Product):

    Database db = new Database(null);
    var Products = db.Insert(typeof(Product));

Inserting records into the table:

    Products.Insert(new Product(1, "Apple", 1.50f));
    Products.Insert(new Product(2, "Orange", 1.75f));
    Products.Insert(new Product(3, "Banana", 1.30f));

Note that attempting to create two tables of the same type, or trying to insert a different type will result in a DatabaseException. After inserting our data, we can query it using MicroLinq:

    var product = Products.Data.FirstOrDefault(p => ((Product)p).Name == "Apple");
    Debug.Print(product.ToString());

Which yields in debugger:
Id:1, Name: Apple, Cost: $1.5

So there are a few issues right now, like that it takes up a whole bunch o’ memory. You can also serialize/deserialize tables with a caveat: it’s not supported by the Netduino firmware. Still, it’s not bad for a few hours of coding.

You can grab the source at http://mu.codeplex.com. If you use it, let me know how you went.

<section>
    <input type="range" min="0" max="2" value="1" step="1" onchange="sliderDidChange(this.value)" />
    <span id="sliderText"></span>
</section>

You can do so using a little javascript:

function sliderDidChange(val) {
    var elem = document.getElementById("sliderText");
    switch (parseInt(val,10)) {
        case 0: elem.innerHTML = "I am number one"; break;
        case 1: elem.innerHTML = "I am number two"; break;
        case 2: elem.innerHTML = "I am number three"; break;
    }
}

Javascript is infuriating to me, but I’m slowly learning the ropes.

Not bad I suppose, but I can’t stand to hear myself talk.

public static bool IsAuthorized(int id, string username) {
    if(GetPerson(id) != null)
    return (username == GetPerson(id).User) ? true : false;
    return false;
}

Yeah, I know.

UIKit/UIButton in action

After a few hours of messing around with the default emulator (I really suck at WPF), I managed to create a cute little clone of iOS’s UIKit/UIButton element using the .NET Micro Framework’s presentation stuff. I’m going to see where this goes…

iOS Device Sensing: Technologies & Applications

Speaker: Tristan McNab
Target Audience: Beginner to Intermediate

With the advent of modern semiconductor fabrication techniques sensing devices have now become commonplace in smart phones. The iPhone was revolutionary in bringing accelerometer-based interaction to a wider audience and has been consistently innovated upon with the addition of other sensing technologies – magnetometers, gyroscopes and geolocation/GPS. These sensing technologies have a wide range of applications from simple user interactions to human activity monitoring and augmented reality. This session will provide a broad overview of the sensing technologies available on iOS-enabled devices, what these sensors can be used for, and issues you’ll need to consider when using sensors in your applications.

Bio: Tristan is a PhD student with the Centre for Wireless Monitoring & Applications at Griffith University after recently completing his bachelor’s degree in Microelectronic Engineering. He is currently working with iOS devices in human activity monitoring, determining the characteristics of and designing software for the iPhone in sport, integrating it into a network-centric data collection and analysis system.

The talk is slated for Wednesday the 29th of September and will be recorded for the convenience of attendees, so look here in the future for some footage of me talking about what iOS has to offer developers dealing with Human-Computer Interaction (HCI), personal activity monitoring or even Augmented Reality (AR). This is the first time I’ll be giving such a presentation to a large audience and I’m really looking forward to seeing how well I can pull it off.

Netduino Development Board

Finally, an Arduino clone worth buying! The guys at Secret Labs LLC last week released the Netduino, a sexy piece of kit that runs .NET Micro Framework 4. At $34.95 USD, it’s a steal compared to other Arduino-styled devices. Oh, and it’s also open source – hardware, software, firmware – all of it.

Guess I won’t have to keep working on a CLR EE anymore!

]]> http://huragok.wordpress.com/2010/08/12/netduino/feed/ 3 Solidus photo_overhead emot-razz http://huragok.wordpress.com/2010/07/11/ireality/ http://huragok.wordpress.com/2010/07/11/ireality/#comments Sun, 11 Jul 2010 02:56:19 +0000 Tristan http://huragok.wordpress.com/?p=241 ]]> There are only two fields of technology I try my best to keep abreast of: systems programming and ubiquitous computing – specifically wearable computing. From the academic research of Steve Mann, MIT Media Lab and ETH Zürich to inventive do-it-yourself hacker community, the ability to have synthetic information augmenting and influencing my day to day activities has been a dream.

<insert name>ViewController.h:

#import <UIKit/UIKit.h>
#import <CoreMotion/CoreMotion.h>
#import <Foundation/Foundation.h>

@interface LowLevelViewController : UIViewController {
    CMMotionManager* cmm;
    NSOperationQueue* motionQueue;
}
@end

<insert name>ViewController.m:

- (void) viewDidLoad
{
	cmm = [[CMMotionManager alloc] init];
	if(!cmm.accelerometerAvailable) {
		NSLog(@"Accelerometer not available");
	}
	else {
		cmm.accelerometerUpdateInterval = (double)1/50;	//50Hz
		motionQueue = [[NSOperationQueue alloc] init];

		[cmm startAccelerometerUpdatesToQueue: motionQueue withHandler: ^( CMAccelerometerData* data, NSError* error) {
			 NSLog(@"Accelerometer: %@", [data description]);
		 }];
	}
    [super viewDidLoad];
}

- (void) dealloc {
    [motionQueue release];
    [cmm release];
    [super dealloc];
}

Look at that caret (^) in viewDidLoad(). Ugh.

Over the past few months, I’ve been researching ways to get .NET Common Intermediate Language (CIL) bytecode executing on 8-bit microcontrollers, or something that can translate CIL ahead of time (AOT) into a native binary. Turns out there are a few near-miss solutions to my problem, so I present to you some of the projects others have done.

_

GCC4NET/GCCCIL — GCC4NET does the unthinkable and produces managed CIL bytecode from unmanaged C source code. Conversely, GCCCIL produces unmanaged native machine code from input CIL bytecode. While the former extension to gcc has little bearing on our problem thanks to better solutions being available (VC# and Mono) that are far more mature, the latter is very pertinent to our problem. However there are of course sticking points…

Firstly, support for essential features of the execution runtime are missing like objects/arrays (and therefore garbage collection), exceptions and generics (oh how I love thee!). Secondly, even if these features were present, you’d need to either try and merge it into the gcc for your microcontroller of choice (like avr-gcc), or fork the distribution and maintain updates. I think that would get pretty damn tedious after a few updates don’t you?

Still, it’s a pretty interesting evolution of the collection and looks to be reasonably active (July ’09). We can only hope someone implements a C# frontend for gcc in the future, BCL dependence be damned. Godspeed, unknown coder!

Pigmeo — A wonderful project that could solve all that ails me with the unfortunate problem of being dead (latest release being April ’08). The goal was to produce a toolchain that takes any managed .NET executable, runs it through a few processes and generates assembly language source for your target architecture. Looking through the source distribution of Pigmeo reveals some interesting ideas, but alas it is truly dead and doesn’t look to be picked-up by anyone.

Dot Net Anywhere — when .NET and Mono doesn’t do it for you, you could always roll your own with Dot Net Anywhere. Though it looks like this project is in purgatory with the latest release being May ’09, DNR offers a more full-featured .NET experience with the exception of multi-dimensional arrays… I think I could live with that. Out of all the projects I’ve found, DNR represents the closest solution to an 8-bit .NET environment. Mr DNR Developer, please keep on truckin’.

CrossNet & XMLVM — Cross-compilation is pretty tricky stuff. Both projects are cross-compilers but the modus operandi for each is different. Whereas CrossNet parses .NET assemblies and generates emulated and unmanaged C++ source code ready for compilation by another compiler, XMLVM transforms .NET assemblies (amongst others) into an XML intermediate format so that multiple languages can compile from the same representation.

Suffice to say, upon further examination of each, I found XMLVM to be unsuitable for my problem and CrossNet to be a little immature. I’ll be watching both as they both are active projects with bright futures. I guess it’s a case of “watch this space”.

Further Afield — Looking at .NET’s retarded brother Java, there has been much more work done in creating dedicated virtual machines for microcontrollers such as NanoVM and TinyVM, both no longer actively maintained. One interesting and potentially useful project is Darjeeling, a JVM that is geared towards memory efficiency. Check out these papers on Darjeeling.

_

So with all that in mind, I wouldn’t mind taking a shot at some Darjeeling equivalent for the .NET framework. Time to experiment I think!

If you’re like me, you want an iPhone OS-themed website. You’ll also want a dynamically-generated website – static pages and forms are so 1997. The good news is that it’s really easy to do, will cost you nothing and most of the heavy lifting has been already done for you. Today we’ll examine how to build quick ‘n’ dirty web applications for the iPhone platform using Mono, ASP.NET and a theming kit called iWebKit. If you’re an old web development warhorse, this is not for you. If however you’re just starting out in the field, this is probably right up your alley.

_

Theming Options

Undoubtedly one of the best features of the iPhone platform is Mobile Safari. Safari utilizes the WebKit layout engine and is capable of rendering pages using HTML5, CSS3 and good ol’ JavaScript. There are a number of frameworks out there that work with Safari (or most other WebKit browsers in fact) like iWebKit, iUI and jQTouch. I chose iWebKit because it’s a nifty theming kit that gives web pages iPhone-styled flair, and from beginner to advanced users, it’s crazy easy to use.

_

A New Solution

So in this demo / tutorial, we’ll be creating a web application that gets two integer values from the user, adds them together, and returns the result back to the user. We’ll also be wrapping these HTML form elements in iWebKit sexyness. If you want to code along, you’ll need an iPhone, iPod Touch or a WebKit-based browser (like Midori), Mono, a wireless Ethernet connection if you want to view the webapp on your iDevice, and finally iWebKit.

Let’s start by creating a new ASP.NET web application in Mono (File -> New -> Solution…) and call it AdditionCalcApp (how imaginative!). Go past the second dialog and hit forward. What you’re presented with at this point is an empty barebones app that will give the user a button to click on and when clicked it will change the text on the button to a new value.

While we’re setting-up, we might as well do two necessary things – configure xsp2 to accept LAN requests, and deploy our theming kit into a resources directory. Go to the Solution Browser, right-click on the AdditionCalcApp project and select Options (or, Project -> Options in the menu bar).

In the Run Section of the project options, select the XSP Web Server subsection and enter your machine’s IP address in the appropriate field. To check if your setup is working properly, save these changes and hit F5 to build and run your project. Fire-up Safari on your iDevice and navigate to “http://xxx.xxx.x.x:8080/” – if it’s working properly, you’ll see a button you can click and it’ll change from “Click Me!” to “You Clicked Me!”. If not, you’re on your own!

The second part of the setup is adding iWebKit to your project. Now, the method I present is quick and dirty and probably shouldn’t be used for enterprise-scale web applications, but it serves it’s purpose. In the Solution browser, right-click on your project and select “Add -> ASP.NET Directory -> Theme“. This will add a folder to your project which will contain iWebKit’s files. From the Framework directory in the iWebKit archive, extract css/, images/ and javascript/ into the project folder you’ve just created.

_

The Pretty Stuff

Now that we’re all set up, let’s get coding some HTML (in Default.aspx). Our page is split into two distinct sections: the head and the body. The head incorporates our theming and meta information and the body contains our addition input form.

<head>
  <meta content="yes" name="apple-mobile-web-app-capable: />
  <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
  <meta content="minimum-scale=1.0, width=device-width, maximum-scale=0.6667, user-scalable=no" name="viewport" />
  <link href="Theme/css/style.css" rel="stylesheet" media="screen" type="text/css" />
  <script src="Theme/javascript/functions.js" type="text/javascript"></script>
  <title>ASP.NET + iWebKit Demo</title>
</head>

There are a few things to note in the head section. We have two meta tags telling the browser that this is a mobile Safari-based web application (lines two and four) and two tags that tell the browser to use the iWebKit CSS and JavaScript theming code (lines five and six). To utilize the shiny things in iWebKit in Safari, we have two main sections in the body region: the topbar divider and the content divider. The topbar divider specifies the navigation bar component of the theme and can specify links to and from other pages and a title for the page:

  <div id="topbar">
    <div id="title">ASP.NET + iWebKit</div>
    <div id="leftnav">
      <asp:hyperlink navigateurl="Default.aspx" runat="server" imageurl="Theme/images/home.png"></asp:hyperlink>
    </div>
  </div>
  <div id="content">
    ...

The title divider of the topbar is obvious, it’s the textual in-page title of the application. The leftnav divider allows navigation to other pages, however I’ve set it redirect back to the page we’re on (a simple way of refreshing the page … I’m lazy). Moving on!

_

Nice Body!

In our content divider we’re going to place our form and some basic instructions to the user. Our form is going to have two inputs (TextBoxes A and B) and a button to run the inputs against the server to calculate our function (addition) and present the result. Code dump!

<div id="content">
  <form id="form1" runat="server">
    <span class="graytitle">Form Example</span>
    <ul class="pageitem">
      <li class="smallfield">
        <span class="name">Value A:</span>
        <asp:textbox id="A" runat="server"></asp:textbox>
      </li>
      <li class="smallfield">
        <span class="name">Value B:</span>
        <asp:textbox id="B" runat="server"></asp:textbox>
      </li>
      <li class="button">
        <asp:button id="submit" runat="server" text="Calculate" onclick="submitClicked"></asp:button>
      </li>
    </ul>
  </form>
  <span class="graytitle">Instructions</span>
  <ul class="pageitem">
    <li class="textbox">
      <p>Click the two textfields to enter integer values. Click the button to add them together.</p>
    </li>
  </ul>
</div>
<div id="footer">
</div>

More of information about the span formatting tags is available in the iWebKit Documentation, but suffice to say each list tag represents an element in a grouping of elements. For each form element we give it a name (A, B or submit), some other properties and we tell them to submit these values to the web server. One thing to note is the OnClick property of the submit button. This property tells the server to invoke the submitClicked method in Default.aspx.cs, the codebehind for the page, when the user hits the button.

_

Code Behind Style

public partial class Default : System.Web.UI.Page
{
    public virtual void submitClicked(object sender, EventArgs args)
    {
        submit.Text = "Result: " + (Int32.Parse(A.Text) + Int32.Parse(B.Text)).ToString();
        A.Text = " ";
        B.Text = " ";
    }
}

Before

This is the easy part. The above snippet replaces the generic method in Default.aspx.cs that Mono generated for us when we created our project. When the user clicks/touches the button on the page, the form information is submitted to server and the button event handler is invoked. We parse the text fields A and B with the static Int32 class method Parse(), add the numbers together, convert it back to a string and set the button label to that result. For the sake of being nice, we clear the A & B text fields to a non-value. Illustrated to the right are before and after shots of the web application in action (click to make big).

After

Now there are some caveats with this web application. The biggest one is that there is no error checking and there is no input validation. If the user enters a non-integer in either of the text fields, then the server is going to throw an exception and crash. This leads to the second ‘fault’, that is, there is no recovering from the fault once it’s made without loading-up the application again. The application is using the basic error page generated by xsp2 and it’s pretty non-user-friendly to say the least. There are options to configure more useful error pages but that lies outside the scope of this tutorial.

_

Review

Hopefully this tutorial has given you an idea how you can create easy to use and pretty web applications for mobile Safari using iWebKit and ASP.NET. In the future I will be presenting some more advanced web application tutorials that utilize databases and RESTful web services to do nifty and awesome things. Hope to see you then!

• Accelerometer-Simulator (iPhone App)
• UDP (Processing Library)

_

The Rundown

_

Basically, this snippet uses the listening capabilities of the UDP class to listen on a designated port for incoming UDP transmissions. The Accelerometer Simulator app streams a formatted packet (see the Google Code Project) over UDP to the host running the Processing Sketch.

Once received, the sketch splits the data packet into separate tokens, converts them into a 3D Vector (global variable p) where upon entering the drawing loop of the sketch, provides the location to which the 3D cube is drawn to relative to the center of the window. In order to make the movement of the cube more pronounced (acceleration ranges are approximately ±2.5g), an acceleration scaling factor was used to multiply the incoming acceleration samples.

_

The Code

_

iPhoneAccelerometerProcessing.pde:

import hypermedia.net.*;

// Global Variables
UDP udp;
PVector p;
final float prescaler = 20;

// Setup Method / Entry Point
void setup()
{
    size(screen.width/2, screen.height/2, P3D);
    udp = new UDP(this, 6000);
    udp.listen(true);
    strokeWeight(4);
    p = new PVector(0,0,0);
}

// Draw Method / Per-Frame Drawing Routine
void draw()
{
    background(255);
    translate( (p.x*prescaler)+width/2,
               (p.y*prescaler)+height/2,
               (p.z*prescaler));
    rotateY(0.5);
    box(100);
}

// UDP Data Packet Listener
void receive( byte[] data, String ip, int port )
{
    String message = new String(subset(data, 0, data.length-2));
    String[] toks = splitTokens(message, ",");
    p = new PVector( float(toks[2]), float(toks[3]), float(toks[4]) );
}

Thanks to the Apple University Consortium, I’ve been selected to go to WWDC 2010 this year. This grant scholarship is grant worth $2000 AUD:

• Return economy airfares to San Francisco, USA from Australia.
• Return economy domestic airfares as required to point of departure from Australia.
• Twin-share accommodation in San Francisco at the Courtyard Marriott for up to 7 days
• WWDC Conference Ticket

Though it’s still not fully confirmed, sources say it’s to be held June 28 to July 2 in California. Time to get the ol’ passport sorted…

I had the privilege last week to attend one of AUC’s iPhone SDK Workshops from the 7-9 April in Perth, Australia. The three-day workshop covered in some detail the skills required to develop for the iPhone / iPod Touch platforms, ending in a development contest to see who could best apply their newfound knowledge (for a $50 iTunes Store Gift Voucher … meh).

Specifically, the workshop covered (in no particular order):

-

I had a really great time (barring the flight to Perth, a five-hour bore) in Perth, it was a fantastic city with a great vibe. Much thanks to the staff of the Cliftons Training Center Perth, and a special thanks to Louis and Brock for demonstrating the workshop!

-

Photos

-

Ice Crystal Formation at 10,000 ft. - "Hey Jim, there seems to be a crack in the window!"

Perth, WA - Brisbane ... but better.

Perth Cityscape / King's Park + One Goon

iPhone Developers in Training - Mother of God!!!!1

Black Swans w/Goslings - "Whatchu lookin' at Swaaaan!"

So, you want to write a compiler huh? If that’s what you want, then you’ve come to the right place. This is the first article in a series of (hopefully) many that deal with compiler construction using the Lookahead Recursive-Descent method for LL(k) grammars. Now, this method is not used in mainstream compilers these days what with Abstract Syntax Trees and stuff like that. No, this is an earlier method that is fairly easy to grasp by people who understand … wait for it … programming. Where appropriate, I comment on anything that may look tricky and at all times will keep the algorithm simple. If it isn’t simple, you’re doing it wrong. That said, let’s move onto what tools you will need to write your compiler, then a little bit of theory. Sound good?

–

Tools of the Trade

“Manually managing blocks of memory in C is like juggling bars of soap in a prison shower: It’s all fun and games until you forget about one of them.”
– anonymous Usenet user

So it’s no surprise that you can write really complex code with just a few lines of C# and the .NET Base Class Library (BCL). Growing-up with C/C++ and libc, moving to C# and .NET was a culture-shock. Not having to really worry about memory allocations and object references? Fan-fracking-tastic I say! So as you’ve probably guessed, we’ll be writing our compiler in C#. I’m using Mono/MonoDevelop, but any .NET 2.0-compliant compiler/runtime will compile/run this software.

Since our output files are going to be in assembly language, we’re going to need an assembler. I prefer Flat Assmbler (FASM), but if you prefer GNU Assembler (GAS) or Netwide Assembler (NASM), I’m not stopping you – I just wont help you out in debugging the output.

Finally, we have our execution platform. I’m still hung on the best way of demonstrating that you’re producing real, executable code with the compiler.  At this present time, I’m looking at an illustrative and user-friendly virtual machine (VM) with an Intel x86-like programmer’s model written in Processing, or using something that can host a MS-DOS clone. Luckily, thanks to this being an incremental series we can put that off until another article.

–

Thank-You, Mr. Backus

So in my last entry, I hinted at some projects I had been mulling over. One of those ideas was DS.NET, a port of the .NET Micro Framework (NETMF) to the Nintendo DS (NDS) hardware platform. The NDS is a nifty little piece of hardware with two processors (ARM7, ARM9), two LCD screens (one with touch input), sound I/O and 802.11b Wireless Ethernet. The real reason NETMF should be ported to the NDS is that in doing so, the ability for homebrew application development would become easier for those interested in programming for the NDS. No fiddling around with different graphics modes and control registers, just pure managed C#.

So, in this article I’ll briefly explain what NETMF is, what I think is required to port the NETMF platform to the NDS, and the next steps in the DS.NET project. Now I wont make any promises that there will be a port of the framework, but hey, it’s not like I wont give it a go!

-

.NET Micro Framework: Smart Programming of Dumb Devices

In a nutshell, NETMF is a significantly pared-down version of the .NET BCL running on an CIL interpreter geared towards embedded devices (“bare metal”). The framework can be booted from flash memory and allows applications running in the interpreter to access the underlying hardware through managed drivers. Figure 1 below illustrates the layered levels of the framework:

-

Figure 1: .NET Micro Framework Architecture Layers

-

So the topmost layer is, as with NETMF’s bigger brothers the Compact Framework and the Full framework. the application layer where managed user code executes. To develop applications for NETMF devices requires the NETMF SDK. Directly underneath is the library-level layer, where the .NET Base Class Library (BCL), Windows Presentation Foundation (WPF) and harware-specific libraries are. In the runtime component layer lies the Common Language Runtime (CLR), the Platform Abstraction Layer (PAL), and the Hardware Abstraction Layer (HAL). It could probably be said that each of these three components are separate layers themselves, but hey, whatever floats MS’s boat right?

-

Nintendo DS: A Hacker’s Paradox

Homebrew software development for the NDS has been around for a long time, with hundreds of hackers reverse-engineering the hidden proprietary magic inside. So, what has the NDS got to offer the DS.NET developer?

• Sound
• Microphone
• RTC
• 802.11b Wireless Ethernet

-

DS.NET: A Worthy Challenge, a whole lotta work!

So, there are a number of considerations even thinking about porting NETMF to the DS. Firstly, we are dealing with a multiprocessor system: this means division of labor and synchronization. So knowing that the ARM7 processor has exclusive access to the I/O devices of the system, let’s assign the ARM7 it’s own BSP and make it responsible to the ARM9 processor as a slave. Operating as a slave, we’ll make the ARM9 processor the master which will run all applications and will have it’s own BSP. Secondly, the toolchain is going to be annoying. A whole bunch of code will be required from DevKitPro/ndslib/ndswifi/ndsfat.

So in conclusion, this is a big project. If there’s a developer out there who wants in, let me know (see here) what your interests and abilities are and I’m sure we could work towards something freakin’ cool!

-

[a] Figure 1 extracted from the .NET Micro Framework Porting Kit CHM Documentation

1. Let’s Build A Compiler: Redux
2. DexOS/ARM9, a port of the Intel i386 DexOS to an ARM9 Development Board
3. DexOS/CPADS, a platform-independent virtual machine for Assembly Language Operating Systems
4. DexOS Wiki, comprehensive documentation for the DexOS community
5. A Confidential iPhone Application Project

That list doesn’t encompass ideas that are in varying stages of fertilization, like Arduino32, ProcessingDS and Menuet.NET. Then there are more projects I than I care to count that have been thrown to the wayside. Reflecting upon this messy state of affairs, I declared to myself that I needed to pick a project and follow it through to completion (or at least until I can palm it off to a maintainer who actually cares). This reflection lead to further thought on my programming practices…

I like to start a project tabula rasa, usually with me reinventing the wheel. It usually starts-out as a cool idea, which then proceeds to first-page google searches for existing solutions, a cursory read if the search yields related or tangential results. Finally, it ends up with either a prototype system or complete failure followed by relegation to the dusty project archives.

While this state of affairs leads to the exploration of many cool ideas, these projects never see the light of day or contribute significantly to ongoing software projects. So with my free time (ha!) being significantly small, what do I do?

Prototype the next cool idea!