Craving for Technology

Demo code from my session about Live Tiles & Push Notification for Windows Phone on Microsoft TechDays Canada TV

2012-04-25T00:37:00Z

I'd like to thank all of you who attended my session about Live Tiles & Push Notifications on Windows Phone on the Microsoft TechDays Canada TV!

Live tiles, channeled with Push Notifications, are important for your application's user experience, and are very easily created in either Silverlight or XNA, and with a notification service residing anywhere on the cloud, with Azure being the better solution.

To make it even easier- you can find and download all of the code samples and demos from the session directly from my SkyDrive here.

I'll gladly answer any of your questions posted here or at the Canadian Developer Connection LinkedIn group.

If you missed the session, you may find it on the TechDays TV site or on YouTube for your convinience.

You may also follow me twitter for more @HarariErez.

Also posted on my WordPress blog.

“Push Notifications and Live Tiles in Windows Phone” lecture for the TechDays Canada TV on April 24th.

2012-04-06T16:16:00Z

I’m preparing a lecture about “Push Notifications and Live Tiles in Windows Phone” for the TechDays Canada TV ( @techdays_ca ), which is due April 24th.

Here’s summary of the lecture:

“In Windows Phone, an application does not have to run in order to communicate with the user, rather the Push Notifications and Live Tiles features can be used in order to present live and dynamic information to the user over the pinned applications’ tiles and by prompting pop-up notifications over the phone screen.

In this session we will go through the concepts of Push Notifications and Live Tiles in Windows Phone applications and see how easy it is to create and use them from your own code.“

* Also posted on http://cravingfortechnology.wordpress.com/2012/04/05/push-notifications-and-live-tiles-in-windows-phone-lecture-for-the-techdays-canada-tv-on-april-24th/

Code samples from my "WCF Crash Course" @ SDP March 2012 conference

2012-03-26T23:01:00Z

I just finished lecturing "WCF Crash Course" at the SDP March 2012 conference in front of a crowded room.

Thank you all who attended my tutorial day, and please see the code samples in my SkyDrive, here.

If you can still find room (and I doubt it..), don't miss Ido Flatow's amazing and thorough Advance WCF session.

Starting fresh in Sela-Canada

2012-03-25T01:40:00Z

Now that it has been publically announced by David Basa (Sela's CEO), I can finally write and tell all about the exciting news: Well, after a long preparation period it has finally been decided that I'll be leaving the country with my family on July to join forces with Eran Barlev and become Sela-Canada's Chief Technology Officer for the next three years.

This role will demand the best of my skills, and the best of knowledge that can ever be achieved regarding Microsoft technologies, as I'll have to represent Sela's knowledge and expertise to Canadian customers and assist Eran in making Sela-Canada even grater than it is now.

So, apart from the many arrangements and documents that has to be prepared for the voyage, my time is completely filled these days by bridging any gaps with the newest technologies Microsoft has to offer, while Windows 8 development being only one of them.

You know, I've performed quite a few roles in past years- I've been a programmer, a chief programmer, a development manager, VP R&D and CTO. I also had my own consulting company and done a lot of training and lecturing, but never, ever, have I raised my hands from the keyboard- forever writing code and forever learning new staff; If any, this would be my message to you- forever write code… It’s good to be a manager, and the world needs good managers, but a manager who doesn’t really understand the technology will never be able to deliver the best projects in the best time and with the best cost!

And so, we're already browsing for a house in a good location, arranging for schools and even planning what clothes to take with us to snowy Toronto and which to leave behind, while making arrangements to rent our home here in Israel for the next years.

I do believe we’ll meet in every Sela-Developer-Practice and in Microsoft conferences, and I will keep writing this blog, now more than ever.

Oh, and last but not least: I’ll be lecturing the “WCF Crash Course” tutorial day of the SDP on the coming Monday. Awaiting to meet all who have already registered to the tutorial day.

Erez

Code samples from my "WCF Crash Course" tutorial day in SDP December 2011

2011-12-06T15:28:00Z

I'd like to thank all of you who attended my tutorial day, titled "WCF Crash Course", which is part of the SDP December 2011 conference.

The day started by explaining the basics of SOA and WCF, showing how easy it is to integrate WCF into any distributed application while not compromising on flexibility, extendibility, performance, and customability.
I then moved through the various aspects of WCF, including- contracts, various binding types and abilities, interoperability, security, and more, and also went through the newer discovery and routing abilities of the framework.

This was a crash course, which means that you leave the tutorial day with the ability to instantly start working with WCF, see and understand the complete picture, but there are, of-course, many more details to learn, of-which Manu ellaborates today on his Advanced WCF tutorial day today.

All of the code samples (and more) I showed during the tutorial day are available for download from my public sky-drive, here.

Building Metro-Style Games- On the coming Sela-Developer-Practice 4-8 December

2011-11-01T04:27:00Z

Gaming is the current trend in phones and tablets, with 50% of the applications sold today being games.

On the coming Sela Developer Practice dev-days I will give a full-day tutorial about building metro-style games for the upcoming Windows 8 operating-system.

In this tutorial I will talk about game design and planning, choosing the technology for your next Metro game for Windows 8, using graphics and input APIs, and enhancing it with audio and video.

The tutorial will take place at Sela College, on December 6. See the following link for more details: http://www.sela.co.il/s/SDP/Dec2011/tutorials2.html#d61.

Looking forward to seeing you!

Interesting Memory Leak

2011-07-11T03:08:00Z

I was called to assist a major company with an on-going crash on one of their systems, which is already in production.

The system went out of sync after their latest deployment, while due to configuration problems they had no option of going back to the previous, more stable version, and thus was "stuck" with a failing application right in the middle of their production line.

Having very little time to solve the problem (as they were accumulating more and more angry customers by the hour), I had to learn their architecture on-the-fly, and guess my way through unknown code with the help of three of their in-house programmers in order to find what was going on.

It didn't take long to find out that the crash was caused by a major memory-leak on the server which was suffocating due to the process' enourmous size, but the cause was yet to be found, especially when the time it took for the crash to build up between cycles varied between hours and several minutes. I couldn't yet put my finger on the exact scenario causing it. After a while of trial-and-error trying to re-create the problem and reading different bits of code, I finally had a general direction, pointing at a small scenario in the system, involving the call for a web-service. And then, while digging dipper into the code involved in that scenario, when it finally hit me: in order to call the web-service, the programmer chose to execute a new process (using the "Process" class) running "Internet Explorer" from the server code, while supplying it with the web-service REST Uri as command-line parameter. This caused the server to spawn many internet-explorer processes, without ever killing them... For some reason the programmer also made sure to execute them in hidden mode, thus hidden from the task manager at normal view, explaining why I didn't see them at first.

A browse using NT Process Explorer revealed many IE processes under the server's main process, happily eating up lots of memory bytes...

All that was happening in varying waves since they were triggered by user actions, depending on the volume which was changing by the hour.

Now, how's that for an nasty little bug?...Of-course, I altered the code to use System.Net.HttpWebRequest (not even WCF at that steaming stage) in order to make the call to the HTTP web-service directly and have the problem finally solved.It took me about 8 hours of work, but the problem was finally gone and DEF-CON could be lowered back to green for that specific organization.

Well, writing code isn't just about these lines of syntax that makes up an application, it's also about making the right decisions at the most remote areas of our program, as the tiniest decision may become the most critical for the system...

Kinect Gestures

2011-06-30T04:03:00Z

After a long wait- Microsoft finally released the beta SDK for Kinect on PC earlyer this week.

Being one of the first to ever get an XBOX 360, waited for two years for Kinect to arrive (it was called "NATAL" back then) and been waiting for the ability to fiddle with it ever since, I gladly downloaded and installed the SDK.

Well, the first thing to say about is that it's fun!

But, without still going into the raw detail- the main issue is the collection of joints you receive from the SDK whenever data changes.

The SDK defines a list of well-known joints, for each the engine attempts to detect and track, but may also infer from other data.

Let's assume that the Kinect camera is set up in-front of you, while the table hides your toes. Kinect will detect and track you knees but will infer the location of your toes, assuming that you have standard legs...

If Kinect is unable to infer the location of an obscured are of your body, these joints will not be tracked until available.

Here's the list of joints, as defined by the JointID enum:

  public enum JointID
  {
    HipCenter = 0,
    Spine = 1,
    ShoulderCenter = 2,
    Head = 3,
    ShoulderLeft = 4,
    ElbowLeft = 5,
    WristLeft = 6,
    HandLeft = 7,
    ShoulderRight = 8,
    ElbowRight = 9,
    WristRight = 10,
    HandRight = 11,
    HipLeft = 12,
    KneeLeft = 13,
    AnkleLeft = 14,
    FootLeft = 15,
    HipRight = 16,
    KneeRight = 17,
    AnkleRight = 18,
    FootRight = 19,
    Count = 20,
  }

Whenever a new skeleton frame is ready, the SDK fires an event containing a collection of detected skeletons (as of now- up to two). Each skeleton contains a collection of all joints, stating wheather each of them was tracked, inferred or not-tracked, and their current position.

Now, all that raw data is interesting but something is still missing- Gestures.

Think of a scroll gesture- moving one of your hands from left-to-right at a constant rate, or a clap gesture- moving both hands to the middle and creating a clap sound (remember that we do have audio capturing input that we can time together with the hand movements!).

Gestures are not currently offered by the SDK and are a major part of my little project, and so I've been developing a small gesture detection engine on-top of the SDK in the past few days.

On my next posts I plan to share some of the code I've been working on and ask for your contributions, as such an engine also requires algorythems which I'm not sure I already got hang on all of them.

^^Kinect Wave^^

See ya!

WCF Crash Course at Sela Dev Days

2011-06-30T02:24:00Z

Ido Flatow and I gave a crash course (full day of study- 9am thorugh 5pm) about WCF at the Sela Dev-Days.

Starting with "What is WCF" and demostrating how to build simple services, we went through the complete "whats" and "hows" of the WCF ideas.

We showed how to build services, understand and define contracts, and choose between the different ways to host and monitor services.

As the day went on we also dived even deeper into security, reliabilty and the different options WCF allows to be extended- to be used when all other options fail.

This crash course was not meant to create instant one-day-over WCF developers, but rather to show and demonstrate how WCF makes it so much easier to create distributed-systems with very few lines of code and configuration, and give developers a major jump-start on their way to understand it.

The presentation and code samples can be downloaded from Ido's sky-drive: http://bit.ly/wcfcrashcourse201106

I can only recommend Ido's planned presentation about the Fiddler tool on Thursday. Don't miss it.

More information here.

SOA to the Works

2011-03-15T21:33:00Z

Tomorrow (16 Mar 2011) at 13:00 I will be giving a lecture at the Sela Developer Practice (taking place at the Crown Plaza hotel- Tel Aviv), labeled: "SOA to the Works- Integrating AppFabric, WCF 4, and WF 4".

In this lecture I plan to describe SOA key attributes through the eyes of WCF and WF, and show how they integrate along with AppFabric to create SOA applications.

I also plan to create an on-the-spot architecture for an application that requires SOA and show how it all adds-up.

See you there!

What did I just code?

2011-03-07T06:17:00Z

Microsoft .Net and Visual Studio (especially the latest 2010 over 4.0) offer many automatic tools and code sugar that allows us to write code faster and safer.

But, every once in a while it is recommended to peek under the hood and see what the compiler had in mind, and how far it is from what we originally meant in our code.

I do that using the .Net Reflector, lately becoming a paid product and yet worth its price, at least for me.

For example- I guess you're already familiar with Lambda expressions. But, there are situations where using Lambda expressions without caution might create severe bugs and performance problems.

See the following code which you can copy to your Visual Studio and test:

public static int CalculateFactorial(int number)
{
  int result = 1;
  for (int i = 2; i <= number; i++)
  {
    result *= i;
  }
  return result;
}
 
public static void Test()
{
  for (int counter = 1; counter <= 10; counter++)
  {
    ThreadPool.QueueUserWorkItem(state => 
      Console.WriteLine("Factorial of {0} is {1}", 
      counter, CalculateFactorial(counter)));
  }
}

It looks like we've created an efficient and elegant piece of code, aimed to calculate factorials of numbers between 1 and 10 while making the most of our computer processors, as we're breaking these calculations to different threads.

So, where's the catch?

Let's open the .Net reflector and see the compiled code for the "Test" method:

public static void Test()
{
  for (int counter = 2; counter <= 10; counter++)
  {
    ThreadPool.QueueUserWorkItem(delegate(object state)
    {
      Console.WriteLine("Factorial of {0} is {1}", 
	counter, CalculateFactorial(counter));
    });
  }
}
 
OK, so we found out that Lambda expressions are actually compiled into .Net

anonymous delegates. Lambda expressions are only code sugar..

Big deal. Still, where's the catch??

The first catch is that .Net reflector is smart enough not to display the actual

code, but more of a sweetened version of the code.

In order to see the actual code we either need to view it in IL, or change

the reflector optimization mode to .Net 1.0.

Here's the code once again, in .Net 1.0 mode:

public static void Test()
{  
  WaitCallback CS$<>9__CachedAnonymousMethodDelegate1=null;  
  <>c__DisplayClass2 CS$<>8__locals3 = new <>c__DisplayClass2();  
  CS$<>8__locals3.counter = 2;  
  while (CS$<>8__locals3.counter <= 10)  
  {    
    if (CS$<>9__CachedAnonymousMethodDelegate1 == null)    
    {        
      CS$<>9__CachedAnonymousMethodDelegate1 =           
        new WaitCallback(CS$<>8__locals3.<Test>b__0);    
    }        
    ThreadPool.QueueUserWorkItem(
      CS$<>9__CachedAnonymousMethodDelegate1);        
    CS$<>8__locals3.counter++;  
  }
}
    
[CompilerGenerated]
private sealed class <>c__DisplayClass2
{  
  // Fields  
  public int counter;   
  // Methods  
  public <>c__DisplayClass2() 
  {
  }  
  public void <Test>b__0(object state)  
  {    
    Console.WriteLine("Factorial of {0} is {1}", 
      this.counter,       
      CalculateFactorial(this.counter));  
  }
}

Browsing through the above generated code, we now find out that anonymous delegates

are also virtual code elements that compile into something else, or- syntactic sugar.

The compiler actually creates a nested class with some kind of garbled name

(in order to prevent code collisions with our code).

This class holds a method that has the implementation of our original "anonymous

delegate", to which the compiler directs the ThreadPool.QueueUserWorkItem delegate

parameter.

We were writing .Net v1.0/2.0 code all along and didn't even know it!...

OK. Now that we understand that, let's see what happened to our "counter" variable-

the compiler added a public field to the nested class holding the implementation

method, by the name of "counter". This counter field is being incremented once for

each loop cycle, just after the internal <Test>b__0 method is assigned for another

ThreadPool thread!

This means that the counter, being a shared resource, will probably make it all the

way up to 10 before the first thread even starts to run, thus causing all of these

threads to calculate the factorial of 10, instead what we wanted them to do:

calculate the factorials of all numbers from 1 to 10…

Such a problem is called: "Captured variables" and can be avoided by passing the

counter as "state" parameter into the delegate, thus causing the delegate to own

a "private" copy of the counter for each thread:

public static void Test()
{
  for (int counter = 1; counter <= 10; counter++)
  {
    ThreadPool.QueueUserWorkItem(state =>
      Console.WriteLine("Factorial of {0} is {1}",
      (int)state,
      CalculateFactorial((int)state)), counter);
  }
}

You can copy the above code to your Visual Studio and see that it now prints the correct

results. You can also open it with .Net Reflector to see what was built now.

You might be surprised…

New articles and labs for Windows Phone 7 & XNA Game Studio 4.0 revealed!

2010-08-24T02:31:00Z

I'm participating in a very interesting project aimed to create new educational and professional material, which are all about the up-coming Windows Phone 7 and XNA Game Studio 4.0 game development for the Windows Phone 7 as part of a group of experts from Sela.

The first phase of resources was already released for public use in the XNA Creators Club site!

It can found on the site, here: http://creators.xna.com/en-US/education/gettingstarted.

We're programming games, writing articles, creating labs and basically having lots and lots of fun :-)

On this phase I personally wrote the "Gestures Article" and assisted/audited in many of the other material.

There is a lot more new content to come on the next phases, for which I'm already busy like a bee.

You're invited to download and give Windows Phone 7 and XNA Game Studio 4.0 a try. It's fun!

More to be revealed in the phases to come.

SDP is Over!

2009-12-31T02:12:00Z

The conference is officially over.

After giving the last "What's new in WCF v4.0" lecture with Noam (which was recorded and videoed), both of us joined the rest to the experts panel in the main hall, which was also videoed by Sela.

Many issues arose- some initiated by the experts, some came from the audience.

At some point, Ido, Gil and I re-joined Oren Eini for yet another round at the NHibernate/Entity-Framework arena, where we finally agreed not to agree.

I'd just like to exclaim that (and I think all of us agree on that) a good architect will always test the requirements of the examined project and choose the best platform for that project. Sometimes Entity Framework would be best, sometimes NHibernate, sometimes the best solution will not include the use of an ORM at all.

It's important to remember that feature lists and feature comparisons are not the only factors (sometimes not even the main factor) in choosing a platform, especially when the the overall sums to a tie.

SDP is over now.

I hope you enjoyed it (if you attended or read our blogs), I know I did.

Summary of ORM day (2) in SDP

2009-12-30T16:54:00Z

Well, it was a full tutorial day. Full of ORM.

After Ido gave his overview and introduction to ORM and EF, Bernie and I had our NHibernate vs. Entity-Framework head-to-head dog fight.

Well, who won, you ask? Depends on who you ask... :-)

Well, we really didn't aim to select one for you, we tried to show you the similarities and differences and help you choose for yourself.

We were followed by Gil's Deep Dive into Entity Framework, and then Bernie and I spoke about ORM Pattens and showed some real world scenarios.

To conclude the day, I hosted the Experts Panel in which Ido, Gil, Bernie, myself, and our guest speaker- Oren Eini, who also contributed two licenses to his EF/NH Profilers (one for each), of which we gave away to those asking the best questions.

The panel allowed us to conduct a free conversation about ORM's in general, dealing with large models, the future of the current technologies, and have a fruitful argument between NHibernate and Entity Framework, with Oren standing firmly for NHibernate.

Most of the sessions were recorded and will be available to conference attendees via the SDP site in the future.

SDP - What's new in WCF 4.0?

2009-12-27T06:15:00Z

Don't forget Noam Sheffer's and mine presentation on SDP, day 4 (Wendenday), regarding what's new in WCF 4.0.

As WCF evolved, new features came to life. We'll talk about WS-Discovery, Serialization and Configuration enhancements, Routing and a few other issues.

Of-course, code talks and bullshit walks...

There will be slides, but there will also be code to back them up.