Aside from making a very addicting mobile phone application, AR is now being considered in industrial settings. It can be used to diagnose and troubleshoot machinery, or provide visual instructions for assembly or disassembly. For example, this video shows an AR program walking the user through the steps of changing a circular saw blade. This particular program was created with the Vuforia Studio Pilot Program.

Vuforia Studio Pilot Program

The Vuforia Studio Pilot Program integrates 3 distinct platforms: ThingWorx, Vuforia, and PTC Creo Illustrate. ThingWorx is crucial for transmitting data between devices, such as sensor data collected from a Raspberry Pi to a phone. PTC Creo Illustrate is a technical illustration software that allows you to create 3D sequences and animations with CAD data. Vuforia can then import data from ThingWorx and integrate it with the 3D models and animations from PTC Creo Illustrate to create an AR environment. With these three platforms, the Vuforia Studio Pilot Program is capable of creating some really cool AR experiences.

I created an AR experience for the 2016 AWC BestFest with the Vuforia Studio Pilot Program. If you’re interested in using the techniques mentioned in this post to create your very own AR experience, sign up for the Vuforia Studio Pilot Program. You’ll then get a service URL that contains your ThingWorx and Vuforia instance.

2016 AWC BestFest Beer Tank Demo

The 2016 AWC BestFest is a technology tradeshow held at Saint Arnold’s brewery in Houston, Texas. The festival is an opportunity for technology partners to mingle, show off new technologies, and drink beer. Another DMC employee gave a seminar on “Smart Manufacturing” and how IoT platforms can improve the industrial process. We decided some AR demos with IoT platforms would help illustrate this point. Being at Saint Arnold’s Brewery, I though it was fitting to have a demo centered around a beer tank.

For the demo, the user scans a specific “ThingMark” with their smartphone. These ThingMarks are essentially QR codes that are tied to unique augmented reality experiences. When you sign up for the pilot program, you get 100 different ThingMarks for your projects. 

Upon scanning the ThingMark, a 3D CAD model of a beer tank appears on the screen alongside with temperature and tank level values. The temperature and tank level values were simulated through a python script on a Raspberry Pi. Additionally, I created a step-by-step visual sequence that showed the user how to open the lid at the top of the tank. 

The following sections give a brief overview of how I accomplished it.   

Setting Up ThingWorks 

ThingWorx Foundation is an Internet of Things (IoT) platform that strives to create a “smart, and connected world”. What does this mean exactly? In this smart world, any and all electronic devices would be able to communicate with each other and execute services. For example, your printer would order its own ink cartridges after detecting low ink levels instead of relying on you. Or, your alarm would adjust when it woke you up depending on whether the train was early or late (look at this DMC blog for a similar project on how to track CTA Buses with a Raspberry Pi). Learn more about how DMC can help you with your IoT projects.  

Creating ThingShapes, ThingTemplates, and Things

ThingWorx is an object-oriented platform centered around “Things”. There are Things, Thing Templates, and Thing Shapes. Thing Shapes are the lowest level, and this is where you define properties, services, events, and subscriptions. So I created two Thing Shapes: TankTempShape, and TankFillShape. Here is where I first defined the temperature, fill level, name, and other properties I wanted to keep track of. I then created a Thing Template called TankTemplate that inherits from my two Thing Shapes. Finally, I created TankThing that inherits from my TankTemplate. The advantage to this object-oriented structure is that I do not have to redefine properties for each Thing I want to set up. If I had multiple beer tanks I wanted to track, then I could easily create several TankThing’s and each one would inherit from TankTemplate and already have the proper configurations. Alternatively, you could define all your properties and configurations within your Thing and it would work fine, but you would not be able to easily scale up your model. Once I created my TankThing, I had to ensure that I could receive data from my Raspberry Pi by setting up an application key.

Creating an Application Key

Each time you access your ThingWorx instance, you must login with your user credentials. So when you make an HTTP request with the Raspberry Pi, you’ll need to send along the username and password before you can alter the ThingWorx data. Alternatively, you can create an application key within ThingWorx for the specified user. Now when we make the HTTP request you can pass along the application key ID instead. Under the home tab, under security, there is a section for application keys. If there isn’t one already created, create a new one for the user you want to use (I used Administrator). Make sure your user has the proper read and write access. When you save it, it should generate an application key ID. Save this ID, you will need it in the next section.

Raspberry Pi Data Simulation

While I chose to simulate data within a python script, you can collect data from a sensor and export that to ThingWorx instead. In order to do that, you’ll need to utilize the GPIO library. You can use this reference to set up your inputs to collect sensor data. While I’m not going to go over my simulation code (wouldn’t really help you unless you wanted to run through the exact same numbers as me), I’m going to show you how to set up the HTTP request.

Making an HTTP Request to Edit ThingWorx

In order to do this, you will need to import the JSON and Requests library. The Requests library is an awesome tool that makes HTTP requests really simple. Everything you need can be condensed into one line of code.

If you don’t have the Requests library already installed, enter the following lines into the terminal to get them.

1.  sudo git clone git://github.com/kennethreitz/requests.git  
2.  cd requests (i.e. change directory into the folder that git has just added)
3.  sudo python setup.py install

Now you’re ready for the HTTP request. The following lines of code only work for my specific ThingWorx and Vuforia instance. You’ll need to replace the URL with your service URL, replace the blacked out portion with the application key ID from your ThingWorx, and replace TankThing with the name of your Thing. That will ensure that the Raspberry Pi is sending the data to the correct location.

Lastly, you’ll need to edit the payload line with your own custom variables. The blue text corresponds to the properties within ThingWorx, and the black text corresponds to the variables within the python script.

Afterwards, save your python script and execute it from the terminal. You can test the script by going into ThingWorx and checking your Thing’s properties. Hit the blue refresh button next to Values to see the values change. If it’s not updating, check to make sure the URL, Thing name, application key, and payload terms are correctly typed. Also check that your python script is properly collecting/simulating values.

PTC Creo Illustrate

Import an Existing CAD Model

PTC Creo Illustrate is a great program for creating animations and visuals, however, you can’t create CAD models. You can use other programs such as PTC Creo Parametric, PTC Creo Elements, SolidWorks, or AutoCAD to create your own model. Alternatively, you can download a file from GrabCAD or other free sites. Once you’re ready to import, go to File -> Import and then select your CAD file. When you click Open you should get a window similar to the one below.

Now you can make edits to your model like rotating or translating your device, creating sections, sequences, and animations. For my particular demo, I created a sequence  that shows how to open the lid at the top of the beer tank.

Creating a Sequence

You can create a sequence to showcase anything from assembly, disassembly, movement, or internal components. Once you have your figure imported, click on the “Sequence” tab at the top of the window. You’ll now see a slew of visual manipulation options.

Click “Add Step” to begin the process. You can now add whatever motions you desire. There are several effects that you can add to individual pieces such as fly in/out, fade in/out, shake, pulse, unscrew, etc. Play around with them to determine what you want. You can add several effects to one step and PTC Creo will do its best to combine them all into one fluid motion. If you want them to be separated, make sure to put them in different steps. Continue to add steps, translations, and effects until you have the desired sequence. You can then go to “Preview Sequence” to view your entire sequence.

Publishing Your File

Once you’re happy with your sequence, you’ll need to publish your program in order to get two files: .pvz file, and .pvi file. The .pvz file is your 3D model, whereas the .pvi file stores your animation information. 

1. Go to File -> Publish. 
2. Publish it as a new .pvz file.
3. Go to your new file and RENAME it as a zip file (do not send to a zip file, for some reason this does not seem to work).
4. Extract all files

After extraction, you should be able to see a .pvz file and a .pvi file in your new folder. These files will be imported into Vuforia Studio.

Vuforia Studio

Here is where all the augmented reality magic happens. Here you’ll set up your 3D models, 2D and 3D widgets, ThingMark, and import ThingWorx data.   

Importing Your 3D Model and Animation

In order to use your 3D model and animations, you’ll need to import your files into Vuforia.

1. On the left under Resources, click the blue plus sign.
2. Click Select File and find your .pvz file and click ADD.
3. Repeat for the .pvi file.
4. Close out of that window. 
5. Drag a 3D Model into your environment.
6. To the right under the “Properties” column, go to “Resource” and select your .pvz file.
7. Under “Sequence URL”, select your .pvi file.

Configuring a Button to Control Your Sequence

Now we have a 3D model and sequence imported into Vuforia, but nothing is currently telling it to run. To fix this, I configured toggle buttons that appear on the smartphone screen that execute play/rewind/forward actions.

1. Select 2D view under Canvas.
2. Drag a Toggle Button onto any of the panels (your choice).
3. Under your Toggle Button properties, drag the blue cross icon next to “Click” all the way to the left to your 3D model icon under “Views”.
4. A new window will appear where you can select what action that button will have. Selecting “Play” will cause the next step in the sequence to play.

Add as many buttons as desired. As shown in the images of the 2016 BestFest demo, I had four distinct buttons: play, play all, rewind, and forward. You can also change what your buttons look like by changing “Image When Pressed” and “Image When Not Pressed” under Properties. You can import your own button images following the procedure for importing the CAD model. Play around with the Toggle Button’s properties to your heart’s content.

Importing Data from ThingWorx

There are several widgets available for displaying values. You can use 3D labels and gauges, or 2D gauges and value displays. Once you’ve selected your widget, you’ll need to connect the value to the ThingWorx Data. On the right-hand side, there is a tab called “External Data”. Click on the plus sign and you’ll be taken to a search engine as shown below.

1. Use the top left search engine to find your Thing by its name.
2. Click the blue right arrow. 
3. In “Filter Services”, type “GetPropertyValues” and click the blue plus symbol when it pops up.  It should now be added to “External Data”.
4. Close out of the search window.
5. Expand “External Data”. 
6. Expand “Configurations”.
7. Select “Invoke on Startup”, and “Auto-Refresh”.
8. Change the Auto-Refresh rate to something that fits your project (I used 1 second).
9. Go to “Current Selected Item” to get a list of all your available properties. 
10. Drag the blue cross icon from the desired property over to the blue circle beside “Value” on your 2D/3D widget. 

This will cause the widget to show the value of the property from the ThingWorx Foundation platform. Repeat the last two steps for all of your widgets. 

Publish Your Experience

In order to save and publish your experience, you’ll need to associate a ThingMark to your experience.   

1. Under 3D view, drag a ThingMark widget (under “Views” in the left hand column) into your environment.
2. Under “Application Parameters”, drag the blue cross icon next to ThingMark to the blue circle next to ThingMark under the Properties  column for your ThingMark widget. 
3. Change the number to match the number of the ThingMark you’ll be using for the experience (it’ll be the name of the file in your ThingMark folder given to you with the pilot program).
4. Adjust the ThingMark widget’s location in your 3D canvas so that it is in the same manner it will be placed in real life.

Now go to “Experience” under Configurations. Give your experience a name in the “Title” box and retype your ThingMark number from before.

Now that everything is set up, it’s time to save your experience and publish it. Click on “Save” in the top left corner, then click on “Publish”. Once it has successfully published, your AR experience is ready to be viewed on a smartphone or tablet with the Vuforia View Enterprise application downloaded.

Vuforia View Enterprise 

Almost finished! The last step is to download Vuforia View Enterprise onto your smartphone or tablet. Once you have it downloaded, open up the application, go to settings, and type your service URL. Now print the ThingMark that you used in Vuforia Studio and scan it with your smartphone or tablet. Open up your experience and enjoy your new augmented reality!        

Learn more about DMC’s Custom Hardware and Software development.

The post Creating an Augmented Reality (AR) Demo with the Vuforia Studio Pilot Program appeared first on DMC, Inc..

Project Goals

My goal for this project was to create a simple dashboard that, at a quick glance, could indicate how urgently I needed to leave my apartment and get down to the bus stop. The 3.5″ TFT display is quite small, and even up close it can be somewhat difficult to read text, so I decided to use a basic color coding scheme instead of displaying the number of minutes left. As an added benefit, this style of display would still be perfectly readable even without my contacts in or glasses on – a common theme of a rushed morning.

The hardware platform needed to have a composite video output as well as web access to get real-time bus arrival information from the online data source. To speed up development, I wanted to use a device that bundled these features together and supported programming environments with GUI building tools. Developing in Python on a Raspberry Pi fit all of these requirements.

For those who aren’t familiar with the Raspberry Pi platform, I would highly recommend buying one and experimenting with it. In essence, it is a very low-cost ($25 and $35 for the available models), credit-card sized computer equipped with USB, HDMI, and Ethernet capability. It has no on-board memory, but instead boots from an SD card, which makes swapping between different operating systems and applications incredibly simple. It is fast enough to output High-Definition video and audio (many people use it as a cheap home theater PC running XBMC) and also has a prototyping area with General Purpose I/O pins that can be accessed directly by application software. In short, it’s a hacker’s dream and perfect for this project.

For the Operating System, I decided to go with one of the most popular choices, Raspbian. Raspbian is a port of the popular Debian Wheezy OS, and has support for a tremendous variety of software packages and programming languages. To get started, I prepared my SD card with the latest version of Raspbian, configured my machine for remote access via openssh, and then set up X11 forwarding to view GUI windows remotely from puTTY. Time to start development!

Creating a Skeleton GUI Application

Although we’re not creating a very complex GUI application, I’ve always found that creating a skeleton application is a great starting point for simple projects. Functionality can be added incrementally, as opposed to coding everything up front, and then debugging later.

There is a wide variety of GUI toolkits available that play nicely with the Raspberry Pi. I quickly decided to use the Tk Framework, partially because I’ve used it successfully in the past, and partially because there is a Python package that interfaces with Tk called TkInter that is well-documented and easy to use.

The code for a basic Python/TkInter window with a programmatically settable background color is criminally simple:

from tkinter import *

if __name__ == '__main__':
    root = Tk()
    root.configure(background='red')
    root.geometry("640x480")
    root.mainloop()

from tkinter import *

if __name__ == '__main__':
    root = Tk()
    root.configure(background='red')
    root.geometry("640x480")
    root.mainloop()

The application creates a Tk window called root that has a background color of red and is sized to 640×480 to match the resolution of the TFT display. The code above is targeted for Python 3.3. If Python 2.7 is used, the first import line will throw an exception. The TkInter package name changed between these versions. To resolve the error, use the following instead for the import line:

from Tkinter import *

from Tkinter import *

With the skeleton project working, it’s time to color code the background based on actual bus arrival times.

Bus Arrival Prediction

The Chicago Transit Authority (CTA), which is the mass transit operator in Chicago, has a great developer API that provides access to real-time bus and train data. Some time back, I applied for a developer API key on a whim and checked out the capabilities of the system. It turns out that the available data matches nicely with the requirements for this project. Every CTA bus has an on-board device that communicates time-synchronized location data back to a central service every minute, and that central service provides estimates of arrival times for each bus, as well as notifications of delays and special service bulletins.

As a bonus, the API is very easy to use. To receive, for example, bus arrival predictions for bus stop 6013 (the southbound Ashland/#9 bus at Webster, which one might use to get to the Clybourn Metra train station from the DMC office), you make the following HTTP GET:

http://www.ctabustracker.com/bustime/api/v1/getpredictions?key=[APIKEY]&stpid=6013

I’ve replaced my API key with [APIKEY], but with a valid one inserted, the response will be a well-formed XML document with a schema that can be obtained from the CTA Developer documentation. Below is the document tree as displayed in Firefox.

I found a very handy Python library called Requests that wraps the built-in python web libraries and dramatically simplifies HTTP functionality. Using this library, I only needed a single line to make this GET and retrieve the XML data:

r = requests.get("http://www.ctabustracker.com/bustime/api/v1/getpredictions?key=" + apiKey + "&rt=" + homeRt + "&stpid=" + homeStpid

r = requests.get("http://www.ctabustracker.com/bustime/api/v1/getpredictions?key=" + apiKey + "&rt=" + homeRt + "&stpid=" + homeStpid

To make the request easier to read, I created global string variables in the Python program that contain the HTTP GET arguments and are concatenated together to form the entire URL. The structure contains the content of the response as well as a host of other information that we don’t need for the first iteration of this application.

Since the response from the CTA web API is a well-formed XML document, I needed an XML parser to extract out the arrival time of the next bus from the bus stop.  Python includes a package called ElementTree which can read an XML document into memory and programmatically read/write attributes and node content.

The XML response for the getpredictions API query typically returns multiple buses and predictions. Our application, however, really only cares about the bus that will arrive the soonest. So, the strategy when parsing this XML document will be the following:

1. Check to make sure the API hasn’t reported an error (the schema specifies how an error will be reported, so this can be done reliably)
2. Check to make sure at least one prediction has been reported
3. Get the predicted arrival time and current system time from the bus that will arrive the soonest
4. Calculate the amount of time, in minutes, until the next arrival

The code for this parsing function looks like the snippet below. Note that I’m using the DateTime package to handle the time interval calculations without reinventing the wheel.

def parseXmlResponse(resp):
    treeRoot = ET.fromstring(resp)
    predList = treeRoot.findall('prd')

    # Check for an error response first
    if (treeRoot.find('error') == "None") or (len(predList) == 0):
        print("CTA API Reported Error")
        root.configure(background='gray')
        return -1
    else:
        # Get the time difference in minutes
        currTime = predList[0].find('tmstmp').text
        predTime = predList[0].find('prdtm').text
        t1 = datetime.datetime.strptime(currTime.split(' ')[1],'%H:%M')
        t2 = datetime.datetime.strptime(predTime.split(' ')[1],'%H:%M')
        arrMin = (t2 - t1).seconds / 60.0

        return arrMin

def parseXmlResponse(resp):
    treeRoot = ET.fromstring(resp)
    predList = treeRoot.findall('prd')

    # Check for an error response first
    if (treeRoot.find('error') == "None") or (len(predList) == 0):
        print("CTA API Reported Error")
        root.configure(background='gray')
        return -1
    else:
        # Get the time difference in minutes
        currTime = predList[0].find('tmstmp').text
        predTime = predList[0].find('prdtm').text
        t1 = datetime.datetime.strptime(currTime.split(' ')[1],'%H:%M')
        t2 = datetime.datetime.strptime(predTime.split(' ')[1],'%H:%M')
        arrMin = (t2 - t1).seconds / 60.0

        return arrMin

Now, all we have to do is change the background color of the window based on the number of minutes left until the bus arrives. I added the following code just before the return statement of the parseXmlResponse function:

        # Color the background appropriately depending on
        # the amount of time left before the bus arrives
        if (arrMin >= 8) or (arrMin <= 2):
            root.configure(background='red')
        elif arrMin < 5:
            root.configure(background='yellow')
        else:
            root.configure(background='green')

        # Color the background appropriately depending on
        # the amount of time left before the bus arrives
        if (arrMin >= 8) or (arrMin <= 2):
            root.configure(background='red')
        elif arrMin < 5:
            root.configure(background='yellow')
        else:
            root.configure(background='green')

Automatic Updates

Despite all of the code we’ve implemented so far to get the predicted times from the CTA web API and shade the background of the screen accordingly, at the moment, nothing will ever kick off the updates

Luckily, there is a lot of support in Python for threading, and we can utilize this functionality to create a thread that runs the update code on a regular interval.

The first thing we need to do is create a class that inherits from the Threading.Thread class and knows which function to call when the thread is started. I have called the thread TimeUpdater, and the code looks like the following:

class TimeUpdater(threading.Thread):
    def __init__(self, updateFn):
        threading.Thread.__init__(self)
        self.runnable = updateFn

    def run(self):
        self.runnable()

class TimeUpdater(threading.Thread):
    def __init__(self, updateFn):
        threading.Thread.__init__(self)
        self.runnable = updateFn

    def run(self):
        self.runnable()

The class is simple. Now, we need to write the code that will be executed at the given interval. The strategy I used was to create a function with an infinite loop of the following:

1. Query the CTA API
2. Parse the response XML and update background color
3. (Optional) print some debug information to the console
4. Sleep for the update interval time

The code looks like the following:

def updateArrivalTime():
    while True:
        r = requests.get("http://www.ctabustracker.com/bustime/api/v1/getpredictions?key=" +
                         apiKey + "&rt=" + homeRt + "&stpid=" + homeStpid)
        parseXmlResponse(r.content)
        print('Data Updated at ' + str(time.time()))
        time.sleep(updateInterval)

def updateArrivalTime():
    while True:
        r = requests.get("http://www.ctabustracker.com/bustime/api/v1/getpredictions?key=" +
                         apiKey + "&rt=" + homeRt + "&stpid=" + homeStpid)
        parseXmlResponse(r.content)
        print('Data Updated at ' + str(time.time()))
        time.sleep(updateInterval)

Only one more step remains: we have to start the update thread when the application is started. I created a function to handle this and called it just before the call to the root window’s mainloop function:

def startUpdateThread():
    updateThread = TimeUpdater(updateArrivalTime)
    updateThread.start()

def startUpdateThread():
    updateThread = TimeUpdater(updateArrivalTime)
    updateThread.start()

Optimization

What we’ve got here is…. an application that fits all of the design objectives that we started with. However, there was one thing that really bothered me throughout the development of this Python code: hard-coded data. The API Key, home bus stop number, update interval, time delta thresholds for the background colors, etc.. they’re all coded as magic numbers. Even with descriptive variable names, I don’t like the idea of needing to edit the application source in order to change the user’s current location and display preferences.

With a little searching, I was able to discover the ConfigParser library, which is bundled along with Python. This module handles the import and parsing of config files that can be bundled with the Python application. When I originally set up my Raspberry Pi, I enabled file transfer over ssh using sshfs. Using this, I can update the configuration of the dashboard application over the web without ever plugging a keyboard into the Pi.

Let’s first take a look at the structure of the configuration file that ConfigParser will look for. I (somewhat arbitrarily) separated the parameters into two subheadings: Tracker Settings and Color Settings.

[Tracker Settings]
api-key = APIKEY
home-stpid = 6013
home-rt    = 9
update-interval = 30.0

[Color Settings]
too-fast = 2.0
too-slow = 8.0
just-right = 5.0

[Tracker Settings]
api-key = APIKEY
home-stpid = 6013
home-rt    = 9
update-interval = 30.0

[Color Settings]
too-fast = 2.0
too-slow = 8.0
just-right = 5.0

The ConfigParser module reads in the entire config file and then can be searched explicitly for parameters in specific headings. So, for example, to get the update interval of the application, I can execute the following line:

updateInterval = config.getfloat('Tracker Settings', 'update-interval')

updateInterval = config.getfloat('Tracker Settings', 'update-interval')

It didn’t take much time at all to get this working in my application, and I was able to do a little refactoring as well. I created a function called startApp that reads in the relevant config parameters and kicks off the update thread. This is called immediately after the application starts as before.

Show Me the Money!

With the application fully coded, it’s time to test it out on the Raspberry Pi! If you’re interested in taking a look at the full code for this project, you can find it at the DMC GitHub account. Below is a video I took of the application running alongside the official CTA bus tracker web application to confirm that the data is updating correctly and in real-time (now with 40% more props!). Now I’ll never be late for another bus again!

Future Improvements

Like any hobby project, there never seems to be any end to the improvements that can be made. One big improvement that I need to make is to automatically launch the application in a graphical window every time the Raspberry Pi starts. I experimented with this using cron, which is a task scheduler application that exists on Unix-based operating systems (including Raspbian). However, the sticker for me is that you need to start up the X-Window environment first before launching an application that contains a GUI. I’m sure someone has solved this issue before, and the solution is documented somewhere online.

The other thing I’d like to do is include a display that indicates what the weather will be like during my transit hours (7-9am and 5-7pm). There are many data sources available online, and adding this functionality shouldn’t require any major new components, since we’re already doing web API requests, response parsing, and graphical updates!

Eventually, I would like to configure this application entirely through the web by hosting a RESTful API on the Raspberry Pi and connecting to it on a web browser. This would probably replace my preferences file and require the addition of a database to store data persistently, although I could take the easy road and edit the configuration file as the preferences are updated. Decisions, decisions!

I highly recommend checking out the Raspberry Pi on your own. Happy hacking!

Learn more about DMC’s embedded development expertise.

The post CTA Bus Tracking with the Raspberry Pi appeared first on DMC, Inc..

We’ve had a few upsets along the way, but for the most part, the favorites proved why they earned the high seeds. After a last minute video review overturned what looked initially like a C++ victory in the semi-finals, this inaugural championship is between Microsoft’s C# .Net and review beneficiary, Sun Microsystems’ / Oracle / Open-Source-Independent, Java.

Amazingly, put perhaps not surprisingly, the architectures and syntax of these 2 platforms is remarkably similar. For a complete look at the similarities, there are a number of great sites exposed by a simple Google search. Some of these differences are significant, while some are cosmetic, but diving into all of them is well beyond the scope of a simple blog post.

Now, admittedly, I have done much more work on C# projects than I have with Java, and my Java experience is strictly from what I’ve done working with Android Development and anything I could learn from the Java Unleashed book I bought back in 1997 (you know, when I was in seventh grade and they had to give you a CD-ROM with the SDK and examples, since AOL dialup was still too slow to download anything real from the new-fangled “Internet” thing.)

Jumping from C# into Java, I’ve been perfectly able to make basic Android apps, and all else being equal, I honestly would lean towards Java for the simple reason that it is inherently cross-platform. Like other cross-platform languages, this means that code I write on my Windows computer can be compiled and run on a Mac without worry. This advantage means that we don’t have to build the same application 3 times to run on Windows, Mac, and Linux devices, a huge business case for commercial software companies. The Java VM mechanism used to achieve this is pretty neat too, even if it does mean that we are constantly getting barraged by Java update requests at startup. C# is making progress here with the Mono Project, but there is still a long way to go to get the same foothold that Java has.

So the winner is Java, right? Well, not so fast. C# gets a chance for a rebuttal, and rebut it does. By most accounts, C# is slightly ahead of Java when it comes to features, although both, it seems, have been doing a flip-flop where one adds a useful feature and then the other copies it. The biggest area where I think C# stands out is the integrated usage and implementation of types and classes for each. It might just be because it’s what I’m used to, but the system in C# makes a lot more sense to me than does Java.

For example, Java lacks static classes, doesn’t have a tool like LINQ, won’t allow named and optional method inputs, can’t pass inputs as references, doesn’t integrate arrays and collections, and has only watered down support for Generics. Project file management also seems better in C#, with conditional compilation flags and a level of abstraction between assemblies and files and between files and classes. Now, I know that each of these are subjective features, and you can probably even argue that some features are intentionally left out of Java, but I personally have become accustomed to the C# programming style and think that it makes sense.

The bottom line is that both C# and Java are excellent, high level languages, with many similarities and a few individual strong points. I think that environment has a strong impact on which you prefer, but for me, being in a strongly Microsoft-centric workplace, C# is my go to language. Therefore, strongly weighing my own opinion of my own opinion, in a wild game, with a controversial play, at the very last second, on a strongly contested Hail Mary, C# wins in what will safely go down as an Instant Classic.

Semi Final Flashback

Relive the Excitement

The post Programming Madness National Championship appeared first on DMC, Inc..

Learn more about DMC’s company culture.

The post Create a Photo Booth with Your Canon DSLR appeared first on DMC, Inc..