SOFTWARE

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!

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.

Windows 8: The New "Windows" Logo

For those interested in testing out the beta version of Windows 8, the Consumer Preview is now available to the public for download. Microsoft is offering two versions for download, a 32-bit and a 64-bit version. Unlike the previous Windows 8 Developer Preview that was unveiled last fall, the consumer preview of Windows 8 is more fully featured and will likely be similar to what we will be seeing in the final retail release version of Windows 8 later this year.

I won’t be going over what’s new in the Windows 8 Consumer Preview, as many sites like Gizmodo have already gone over some of the new features. Aside from the new MetroUI (which I have previously commented on), there are some other impressive features in Windows 8, such as Storage Spaces (a new storage pooling option which is very similar to the Drive Extender technology seen in the first version of Windows Home Server), as well as built-in Hyper-V virtualization features.

Granted, with the significant amount of changes, not everyone will like Windows 8, as the MetroUI interface is a very touch-oriented user interface that is geared towards touch-based devices and not so much for traditional keyboard and mouse computers and laptops.

You can grab the Windows 8 Consumer Preview (directly from Microsoft) here: http://windows.microsoft.com/en-US/windows-8/iso

Sources:

Windows 8 Consumer Preview ISO Images
Gizmodo – Windows 8 Consumer Preview Hands On: No Going Back

Mark your calendars! For those waiting to get a chance to test out the latest developmental version of Windows 8, Microsoft is unveiling the Windows 8 Consumer Preview build to the public on February 29 at the Mobile World Congress in Barcelona, Spain (according to ZDNet).

This build should be interesting to test out, as it will have new features that were not in the Windows 8 Developer Preview, such as Storage Spaces, built-in Hyper-V, ReFS (next generation replacement to the aging NTFS file system), etc.

Source: ZDNet – Microsoft to launch Windows 8 Consumer Preview at MWC