On the Edge of the Network

Single post

Twin Cities Code Camp #12, Day 2

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! 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!

Write a Comment