GENERAL

Today is the second day of the Twin Cities Code Camp #12 event! The first day of the event was excellent, as there were a lot of great software development topics covered, ranging covering topics such as .NET Framework, WinRT, mobile/web development, as well as programming strategies. To get a recap of the sessions that I went to yesterday, please check out the TCCC #12 Day 1 post.

Like the first day, I will be recording some of the sessions and will make them available here at a later date. For Day 2, I will be attending the following sessions:

* Extensible, Durable JavaScript with Inheritance (Mike Hodnick)
* Pair Programming Techniques (Chris Johnson)
* Move Your Silverlight Skills to the Native Web with KnockoutJS (Judah Himango)
* Windows 8 Apps Crash Course (Jeff Klawiter)
* Islands of Richness: Structuring Rich Client-Side Applications in Javascript (Todd H. Garnder)

I will be updating the post throughout the day. Up first is the session by Mike Hodnick, Extensible, Durable JavaScript with Inheritance!

Update 1: Extensible, Durable JavaScript with Inheritance (Mike Hodnick)

For the first session of the day, Mike Hodnick discussed about different ways to utilize inheritance in Javascript. He began by briefly talking about the current state of JavaScript and some of it’s shortfalls, such as lacking common object-oriented characteristics. He then went over how inheritance can be implemented in JavaScript.

One of the options that he discussed was to utilize private states, which can also be used to prevent modification of data objects. This can be done by utilizing property descriptors, but Mike did stress that this method isn’t actually that private and secure, as anyone determined enough can easily compromise private states.

Mike also discussed how to utilize initialization and constructors in JavaScript, as well as third party libraries (i.e. Backbone, Prototype, Base2, Joose, JSclass) that can be used to implement inheritance. The only downside of utilizing third party libraries is that since the entire library is implemented, any flaws or issues present in those libraries may present themselves in your JavaScript code.

For the rest of the session, Mike went through a Prototype code example and demonstrated the use of the following methods: initialize, speak, add methods, and super initialize methods. At the end of the session, Mike made two recommendations: Expose extensions through API calls or require third party library conventions in your JavaScript code. There is additional information on this topic over at Mike’s GitHub page at: http://github.com/raynos/pd

Update 2: Pair Programming Techniques (Chris Johnson)

This session by Chris Johnson was on pair programming, a type of programming style involving two people directly working together on the same code / project. He began by explaining the benefits of pair programming, as well as misconceptions about pair programming.

Chris then talked about different styles of pair programming, such as “Divide and Conquer” (splitting up coding responsibilities) , “Alternation” (coding together, alternating), “Simultaneous” (coding together, simultaneously), etc. Chris also talked about how pair programming can be done locally (meeting up at someone’s house, coffeehouse, etc.) or remotely (Skype, Go. To, etc.) He mentioned the benefits and cons of each, as well as having a good hygiene (for the sake of you and your programming partner).

Chris stressed the importance of programming personalities, in that compatibility is important for pair programming. When paired with someone who works well with your style, pair programming can be very effective, but at the same time, it can be disastrous when paired with an incompatible programmer.

For the rest of the discussion, he talked about the different work styles in use at Getty Images and went over what programming styles went well and what did not.

Update 3: Move Your Silverlight Skills to the Native Web with KnockoutJS (Judah Himango)

Judah began the session by dramatically saying that Silverlight is dying and will be dead within the next 5-10 years. With the rise of smart phones and with HTML5 pushed out as the supported standard, Silverlight (along with other browser plugins like Flash, etc.) will eventually go extinct. With that being said, Judah highly recommended that current Silverlight programmers should make the jump to HTML5, as it will be well supported for a long time.

Judah then jumped into a live coding session to demonstrate using KnockoutJS with Javascript, which adds more OO-like features such as the ability to data bind. Using KnockoutJS, Judah programmed a music streaming web service, streaming lovely llama music to the audience. With each llama music album, Judah was able to demonstrate that specific “tags” can be bound to each each album object.

Update 4: Windows 8 Apps Crash Course (Jeff Klawiter)

In this session, Jeff Klawiter went over what the new WinRT API will mean for current .NET developers when Windows 8 reaches RTM status. Jeff quickly went over what WinRT is, which is:

• Main runtime for Windows 8
• Similar to .NET but part based on CCOM
• Common runtime supports .NET, C++, HTML/JavaScript, XML, XAML
• Common metadata for code sharing (ECMA 335)
• Common set of objects (System.windows.runtime)
• Unified platform to bridge common APIs to build Metro applications

In addition, Klawiter discussed what C# features will be available in Metro:

• C# 5.0: Async/await
• XAML: “Silverlight 6.0” (an evolution of SL, but Microsoft will not call it this)
• .NET 4.5: Sandbox (limited reflection), Async only, No localhost
• Windows Phone 8 will utilize the same/similar framework

For developing Metro apps for the upcoming Windows 8 Store, Jeff mentioned that Microsoft will be applying a strict quality control policy for application submissions. Any applications that do not meet the full extent of the policy would be rejected by Microsoft. Metro applications can only be developed under Visual Studio 11 Beta, which is only available for Windows 8 Consumer Preview Edition.

Jeff then went through some live code in Visual Studio 11 Beta for developing Metro apps. While going through the code, Jeff went over the basic structure of a Metro app in C# and pointed out several functions that would be needed for Metro.

Jeff then discussed about several aspects of applications in Metro, such as:

• SnapView: Used for visual states and horizontal/vertical navigation. (Windows.UI.ViewManagement.ApplicationView.GetForCurrentView)
• Storage Settings (StoarageWindows.Storage.ApplicaionData.Current)
  • Roaming Settings: Syncs with Windows Live account.
  • Local Settings: Per device only.
  • SignalDataChange: Notifies all settings event handlers.
  • SetVersionAsync: Use with version to figure out if the user upgraded.
  • Metro Applications are Zombies: All applications now suspend, rather than terminate.

For more information on developing Metro applications for Windows 8, Jeff recommended checking out two sites:

Getting Started: http://dev.windows.com
UI Guidelines : http://t.co/hw7CvNhT

Update 5: Islands of Richness: Structuring Rich Client-Side Applications in Javascript (Todd H. Garnder)

For the final session of the day, Todd went through live coding sessions of developing client-side applications in JavaScript. For the coding sessions, he made use of several third-party JS libraries (such as Backbone) to extend the capabilities of his JS application.

The first code session involved building a basic ‘Hello World’ application utilizing Backbone. As he worked on the code, he explained the usage of Backbone and the methods available in Backbone, such as initialize and render. He also introduced Underscore.js, which adds functionality similar to Linked in .NET, as well utilizing template engines (for usage of strings and content).

Todd then moved on a post list demo, where he introduced Require.JS, which can serve as a IOC container for JavaScript. He explained that on load, the library inspects the DOM and looks for the main attributes. Todd also went through the use of the define and require functions in the demo. For the rest of the session, Todd continued to extend features onto the post list demo by adding iGoogle-like widgets. The final result of the demo was that the posts were accessible on the first page and the widgets on the second page of the client application.

For further information on this session, Todd has made the screen cast available over at http://www.wocketware.com/.

Update 6:

With all the discussion sessions done, all that was left was the prize giveaways and the conclusion of TCCC #12. Similar prizes to yesterday’s prizes were made available, although I wasn’t as lucky as yesterday. Jason Bock announced that the next TCCC will be sometime in October 2012, with the finalized date being announced at a later time.

Well folks, that wraps up TCCC #12! I will be making the recordings from some the sessions available online soon. Again, I’d like to thank the TCCC team (and their sponsers) for making this great event available to software developers in the Twin Cities area!

It’s that time of the year again, it’s the Twin Cities Code Camp (TCCC) event! A beautiful, sunny Saturday morning here in Minneapolis, perfect for getting the event started. Well, almost anyway. There was a Gopher charity run going on, so most of the university road entrances were blocked off. Unfortunately, I missed the breakfast and the welcome session, but we have a long day with a lot of coding discussion sessions!

Here’s the discussions I will be attending today:

* 2D Character Animation Techniques for XNA (Ananth Balasubramaniam)
* Leveraging jQuery’s Special Events API (James Greene)
* Javascript Unit Testing with QUnit and Mockjax (Nick Scweitzer)
* Android Development for. NET Programmers (Mike Marshall)
* Open Source 101: Get Involved with GitHub (Keith Dahlby)

For more information on TCCC, and check out their website at http://www.twincitiescodecamp.com/ I will be voice recording the discussions and will post them at a later time.

First up, 2D Character Animation Techniques for XNA!

Update 1: 2D Character Animation Techniques for XNA (Ananth Balasubramaniam)

First discussion was on 2D animation techniques for the Microsoft XNA game framework. Ananth went over utilizing the bone objects of a sample model (built in 3DSMax) directly in XNA. A demo of an animating robotic bone was shown, run in XNA.

Update 2: Leveraging jQuery’s Special Events API (James Greene)

This discussion focused on the Special Events API. Greene briefly went over the version history of jQuery, and the functions that were introduced with each version. He noted that the functions bind, live, and delegate were depreciated in the latest revision of jQuery and that on/off should be used instead. Greene then proceeded to show two programming demos utilizing the Special Events API, Multiclick (simple interactive function that performs an action with multiple clicks) and TextSelect (function that displays texts using the API). Unfortunately, there were some technical issues with executing the code live, so a walkthrough of the code was discussed instead. The code examples can be found in full at Greenest website: http://jamesgreene.net

After this, it’s off to Campus Pizza for lunch! (courtesy of the Nerdery)

Update 3: Javascript Unit Testing with QUnit and Mockjax (Nick Scweitzer)

The first day of TCCC is already halfway over! For the first discussion of the afternoon, I sat in on Nick Scweitzer’s discussion of Javascript Unit Testing with QUnit and Mockjax. Lots of great coverage on the usage of QUnit and Mockjax.

Nick started off explaining the merits of unit testing for Javascript and that KnockoutJS, QUnit and Mockjax provides a great platform for doing so. He then proceeded to discuss the use of KnockoutJS in unit testing and why it is preferable over Backbone, and as it is utilizes an MVC architecture, MVVM, and controller support. Nick then covered the basic syntax of QUnit, going over the usage of module(), test(), asynctest(), and expect().

An MVC application demo (seat reservation site sample) using QUnit and Mockjax was then covered. Nick went through the usage of QUnit and Mockjax in the Javascript code.

The slides and full code samples can be found at Nicks website: http://www.thecodemonkey.net/

Update 4: Android Development for. NET Programmers (Mike Marshall)

In this session, Mike Marshall began by mentioning the current state of the Android Market. He focused particularly upon the large user population and it’s ease of access for developers and explained why .NET developers should care about Android Development. He also brought up the common excuses that .NET developers typically bring up about Java/Android development and argued that it’s far easier to get into than commonly believed.

Marshall then talked briefly about setting up the Android SDK environment and it’s requirements, as well as using Eclipse, it’s functions, and using the Android emulator for testing. Mike also mentioned that as phone providers put out so many different Android phones with varying versions and slow updates, it is very important for Android developers to test your application for intercompatibility between different Android versions, resolutions, and phones.

Marshall went to go over several Android example code for the rest of the session and went over the general structure of a Android program, such as activities, layouts, oncreate, findviewbyid, R, etc. He also pointed about the concepts in which .NET and Android/Java are similar. For the final example, a MovieService app was used, in which Marshall talked about the imprortance of activity stacking, intents, mapview, asynctask, as well as the use of Gson.

For those interested in getting the Android SDK setup on their machines, Mike Marshall’s website has some tutorials on how to do so here: http://www.mike-marshall.net/

Update 5: Open Source 101: Get Involved with GitHub (Keith Dahlby)

For the last session of the day, I decided to attend Keith Dahlby’s discussion of open source software and using GitHub. Keith did a great job in explaining about open source, as well as the nature of making contributions to the code and the community. He then dove into discussing about how to use GitHub for open source projects.

With GitHub, Keith mentioned that it offers a great environment for being able to interact with the open source developers and to make contributions to open source projects. He stressed the importance of interacting with the community, as well as conforming to expected coding standards for projects. Keith also pointed out that forking is extremely easy to do on GitHub. For the rest of the session, Keith went over a live example on using GitHub and it’s functions using his test account on GitHub. A rather humorous meme of Jason Bock was created during this session.

Update 6: Well, it’s the end of the first day of the TCCC #12 event! Like with all TCCC events, there were prize giveaways to attendees. Such prizes included t-shirts, books, accessories, as well as larger prizes like an 32″ LCD TV, Xbox 360, Kindle Fire, and a camcorder.

Surprisingly, my name was drawn during the giveaway, in which I was offered to choose between a pencil holder and a black bag. I decided to get the black bag, as it seemed to be the better of the two. When I received it, I was told to “guard it with my life” and to “open it”, as there was more inside the bag. Inside the bag was a Bose QC15 (a very nice pair of headphones)! I was surprised, as I was only expecting just a simple bag. Either way, I was very happy.

I’d like to thank Jason Bock, Mike Hodgewick, and the rest of the TCCC team for organizing this great event, as it offers a lot of great ideas and concepts for programmers and developers. Coming tomorrow is TCCC #12 Day 2! Check back tomorrow for some coverage on that day!

Yesterday, the VP of my company stops by my desk and shows off the tablet that he picked up during his trip to China. I glanced at it and said, “Oh, it’s an iPad 2.” The VP said, “Yeah, I picked it up for around $180. Here, why don’t you try it out?”

[Show as slideshow]

Right away, I noticed something wrong with this “iPad 2.” The feel of the tablet felt rather fragile and cheap. The markings on the back of the “iPad 2″ had the Apple logo and the typical markings, except… the label said it was a 128 GB version (which doesn’t exist) and a Google Android OS copyright.

Doing some online research, this fake “iPad 2″ is actually a Grefu M97 tablet. Booting it up, I was greeted with the green Google Android robot. Once loaded, the desktop layout was reminiscent from a old version of Android. The performance was slow, and touch capacitive was extremely poor; I had to apply greater pressure than usual for it to register my actions. I was a bit cautious, as the screen was made of cheap plastic and made a slight crackle noise whenever I pressed on it. The battery life was also rather poor, as the battery only seemed to last for a few hours.

Upon checking the system settings on this fake iPad 2, it said it was running Froyo 2.2 (which is almost three years old at this point). With this $180 fake iPad 2 claiming it had 128 GB storage, I checked to see if it had any validity. Of course, that claim too was false, as it actually only had 4 GB of internal storage.

The VP asked me to see if there was any way to improve the usage experience of the fake iPad 2. As this tablet only had access to some third party app market (which barely had any usable apps) and no access to the real Google Market, rooting was the only option. Unfortunately, rooting this tablet is proving to be a bit difficult, as there is barely any information on this device to begin with. We’ll see how this goes.

UPDATE:

Shortly after I posted this, the screen on the Grefu M97 cracked, as I had feared. As the screen was made of some cheap plastic, it just couldn’t handle all the touch pressure. Let this be a lesson in why counterfeit electronics should be avoided, no matter how tempting the price is.

Don’t worry, I’m not dead! I apologize for the lack of updates, it’s been a crazy month for me, both in my personal and professional life.

With tax season in full, I’ve been working away to get my taxes done. As always, taxes are never fun to do, but the tax refunds make up for it (for the most part). Also, as my previous roommate moved back to Korea, I am currently searching for a new roommate. If there’s anyone that’s interested in renting a room in a two bedroom condo unit in Minneapolis, MN near Uptown, let me know (shameless advertising, I know :p )!

As for work, I’ve been recently tasked with overhauling the website for the architecture firm that I work for.  It hasn’t been easy, as the web design firm that constructed their old website was coded very poorly, making updates extremely cumbersome and difficult. I decided to start from scratch, using a CMS, as the objectives were to not only design a nice looking website with a (very) limited budget, but also to make it so that it is easy to update for company employees.

I am using WordPress, as it is a well-supported CMS and has a lot of flexibility, with tons of themes and plugins readily available. Although known more for blogging, WordPress has developed significantly in the past few years in that it is now a viable option for  commercial websites. Also, as the company that I currently work for is an architecture firm, they wanted something creative. As WordPress seems to offer a lot more theming options over other CMS like Joomla and Drupal, it made sense to go with WordPress.

Aside from work, I have recently enrolled in some of the free online CSCI courses that Stanford, UC Berkeley, and U Michigan are offering, such as Software as a Service. Many of the courses were originally scheduled to begin in February, but technical issues have delayed their launch. Additional courses like Design and Analysis I and Game Theory are scheduled to begin next week.

Hopefully, as time frees up, I will be able to get more time to post about some of the personal projects that I have been working on, like the whitebox ESXi 5.0 server.

I recently had the chance to play around with the recently released Windows 8 Consumer Preview build on a Asus Eee Slate EP121 tablet and on a whitebox PC (the same system I used for the ESXi 5.0 evaluation). After a day of running Windows 8 on both systems, here are my initial reactions. While MetroUI as an interface has certainly proven to work well for the Windows Phone 7 platform and for tablets running Windows 8 builds, it leaves much to be desired for traditional desktop and laptop users, as the whole Windows 8 experience seems to make your computer feel like a giant phone/tablet, sans the touch input (unless you own a touch monitor or a touch accessory).

For tablet users, Windows 8 represents a refreshing change, as it does away with the typical windows & icon-based interface (that we’ve been using for the past 20 years) to a tile-based one, which is very touch friendly. The MetroUI interface in Windows 8 is sleek and clean, with apps running launching seamlessly without issue. For a preview build, Windows 8 Consumer Preview is surprisingly stable and performed rather well on the systems I tested it with. At times, Windows 8 seemed to perform better than Windows 7.

For those not too keen about the new MetroUI interface, Windows 8 offers a “classic” desktop mode, which looks very similar to Windows 7′s desktop (with the exception of the Start button, removed in Windows 8). Programs from previous versions of Windows run in this mode, separately from the MetroUI-based apps. With exception of a few legacy games, I did not encounter many incompatibility issues. For the most part, nearly all programs that ran on Windows 7 should run on Windows 8.

Now, here’s the ugly part. For keyboard & mouse users, the MetroUI interface will force users to significantly change the way they use Windows. For some users, Windows 8 will make computing simpler, but for many power users, the new interface represents an awkward and annoying change. Some actions that previously took little effort now seem to take much more effort in Windows 8 with a keyboard and mouse. Some examples include scrolling through the MetroUI Start menu, accessing the new Windows 8 charms, the ability to sleep/shut down the computer, accessing the regular Control Panel (not the new simplified Settings section), etc. While smooth for touch users, as it is now MetroUI just feels clunky with a keyboard and a mouse.

Multitasking also takes a large hit in Windows 8. The ability to view several running programs on a single screen has always been a boon for power users and while users can continue to so with “legacy” programs in Windows 8′s desktop mode, MetroUI does away with all of that, forcing all MetroUI apps to run fullscreen. What’s worse is that while current MetroUI apps look and run fine on a tablet, they are just far too simplistic for power users with large/multiple monitors. For example, the text and spacing in the MetroUI Mail program looks abnormally huge on a large monitor, with much of the white space being wasted.

By pushing MetroUI as the main interface, Microsoft is making a rather risky move with Windows 8. While previous preview editions of Windows 8 allowed the MetroUI interface to be disabled (via registry edits), there is no ability to do so in the Windows 8 Consumer Preview. No doubt that this will not sit well with users that are less than enthusiastic about MetroUI. Don’t get me wrong, I like the new MetroUI interface and there’s no doubt that it’ll work well on tablets and touch-based devices. However, I believe that pushing MetroUI in Windows 8 with no option to disable it may be a mistake, as a majority of the computing population still uses traditional non-touch devices for their computing usage. I fear that by doing so, it may greatly alienate many PC users, particularly those that are not easily adaptable to change.

Even Steve Ballmer even publicly stated that Windows 8 would be their ‘riskiest’ product ever, given the significant amount of change that Windows 8 brings.  Given how people generally reacted to the release of Windows Vista five years ago, an OS which introduced far less changes than Windows 8, I would be worried.