Win a Pluralsight Annual Plus Subscription

To celebrate that I just published my course I’m raffling away the following:

• Pluralsight One Year Annual Plus Subscription + Signed copy of C# Smorgasbord + C# Smorgasbord Shirt
• 2 Signed copies of C# Smorgasbord
• 3 digital copies of C# Smorgasbord

How do I win?

It’s Simple!

Leave a comment on the blog telling me Why you should win a one year subscription for Pluralsight and why you’d like to see my course. A bonus is if you tell me why you also want to read my book!

Last but not least, share this post in your social medias! Tweet it!

Raffle ends on Wednesday June 26th 18.00 CEST

What’s the course about?

In this course we look at MSIL; the code that is generated when you compile C#. We explore MSIL so that you get a better understanding of how C# works and how it is compiled. Ultimately after completing the course you will feel like a better C# developer as you will know much more about what happens behind the scenes when we compile our C# applications.

View my course here and please rate it when you’re done!

The post Win a Pluralsight One Year Subscription and C# Smorgasbord appeared first on Filip Ekberg's blog.

What I mean about combinations of certain criteria is that let us say that we have a set of colors and I’d like to define that my pants have more than one color. Then somewhere in my application I’d like to check whether or not the pants had a certain color or not. This could of course be solved in many different ways. One other way could be to just store a collection of colors on the pants class. That would however make this article less fun. So let’s take a look at how to use bit flags. Both the answer on SO and the link to FlagsAttribute above which has some examples use colors for their demonstrations, this is because it’s a very common and easy scenario.

Let’s say that we define RGB, Red, Green and Blue by using bits. This could mean that we have three colors with bit representations as followed:

Now let’s say that we have all colors together, that means that we have the following bits:

Red, Green and Blue added together! So why does this matter? If you don’t know your bits and bytes it’s going to be quite difficult to understand. There’s an older article that I’ve written about bits and bytes, check that out if this is all Greek to you!

As you see it just “added” the bits together, but how do we do this in C# then? It looks “so easy” on paper! First we need to fine an enumerator for this.

If you’ve peeked at the StackOverflow answer linked above, you might already know that using the attribute Flags doesn’t do anything at all. Except it’s handy if we use reflection and it changes the output when we print the value.

Now, how do we use this enum? It’s also easier than you might think!

By using something called “OR” we can add values together and get a nice bit representation. OR is written with a single | like this:

The value of color will now be 7. Why? If you add the numbers together in the figure which shows the bit representation of Red + Green + Blue, you’ll see that you will get the value 7!

If we go back to the original “Problem” now, how do we check if a certain color exists in this bit representation of colors? Let’s talk a bit about OR first. What OR does is that it checks two bit representations and once a 1 occurs, a 1 is set in the result. That might sound confusing. So let’s say that we have 0001 | 0010 the result of this would be 0011. So the 1 is dominating here, if there’s a 1 in either of the two bit representations that you are “OR”-ing then there’s going to be a 1 at that bit in the result.

As there’s something called OR, there’s most likely something called AND, right? There sure is! That however works a bit different it checks if there’s a 1 in both representations. AND is written with a single & and you use it pretty much like OR. So if we use AND on the following 0001 | 0011 the result would be 0001 because the first bit is the only one that has a 1 in both the representations.

Now you might have already jumped the gun and figured out how to find out if one color occurs in the combination of colors however I’ll just expect that you haven’t! It’s quite easy though when you think about it for a while. If you can use AND to “filter” out everything that is not exactly as the representation that you want, then you can probably use this to check if there’s an occurrence of our bits!

So let us say that we have all the colors 0111 now if we AND this with the color red, which is represented with 0001 the result of this AND operation will be 0001 and thus we found the color red! In C# this would look like this:

As of .NET 4 you can also use Enum.HasFlag which work like this:

Here’s a more complete example of how you can play around with this:

Will you be using this in your applications or do you think this is the completely wrong approach?

The post Using bit fields in C# appeared first on Filip Ekberg's blog.

In 2006 I had my eyes on working abroad and thus I figured that in order to do this I needed to at least have a bachelor degree in Software Engineering. Now 7 years later I’ve had my bachelor degree for a while and I’ve gathered a lot of experience along the way; but what I have not done so far is work abroad.

While there are a lot of interesting things happening in my professional life and in my personal life with my lovely fiancée Sofie, there’s still something that I feel I want to do.

If you’ve missed it, I was recently accepted as a Pluralsight author and my first course is in the works and is going to be about MSIL for the C# Developer. I’m truly honored to do this and I’m really looking forward to getting this out there to all of you.

However, over the years a lot of things have changed. I met my better half and the things that I had previously prioritized changed and the dreams about working abroad were put aside. Now both I and Sofie are in a place in life where we feel that we want to try something completely different. I’m really happy to announce that Sofie and I will share the dream that I once had, which was the fundament of me studying for my bachelor degree; we’re moving to Sydney.

I was offered a position as a senior developer at Readify in Australia and the company is completely in line with what I value and they work exactly as I want. It’s going to be a great experience and I hope that I will meet a lot of new friends and get a lot of new knowledge.

We are both really excited about this opportunity and we are certain this is going to be a blast.

The post It is time for a new challenge appeared first on Filip Ekberg's blog.

We are moving towards a new era where more and more people want to offer the possibility to expand the system with widgets and plugins. By utilizing Compilation as a Service can make it easier for all parties to create plug-ins. For instance operations performed at certain events in an application.Roslyn exposes a C # and VB.NET compiler and we can use this to implement something along those lines. Listen to me give an introductory talk about what Roslyn has to offer and how we can use Compilation as a Service to enable the next level of plugins.

Check out my talk from dotnetConf on the subject and let me know if you’ve got any cool ideas on how to utilize compilation as a service (Roslyn).

You can download the demos and slides here.

The post Utilize Roslyn to create the next level plugin capability appeared first on Filip Ekberg's blog.

The following article is an article that I wrote duing my studies for a bachelor degree in Software Engineering. Minor changes might have been made to make it more suitable on this website. It was originally posted on my old blog in 2008 but have now been re-processed.

Both my experience and writing style has changed since I wrote this article, but I still want to share my thoughts from 5 years ago.

Let me know how you prefer teaching others and how you prefer to learn!

Side note: C# Smorgasbord in PDF format is available for €4.99! Buy it directly on PayPal and receive the PDF, ePub and Mobi today!

Abstract

A teacher knows that there are no straight answers on how to teach. There are multiple ways giving people new information and helping them adapt this in their current work. One of the preferred learning method by me is the Problem Based Learning, I will take up more about this in the upcoming topics. It’s also very important to take the age of the student in mind, how do they actually see on you as a teacher and does your and their age really matter?

Introduction

By passing on knowledge to new generations we somewhat evolve into a new and different kind life form. This not being as deep as it sounds, every day we somehow pass knowledge to someone. It might be the neighbor, a child, a sibling, a parent or anyone else for that matter.

The important thing to remember is that all new or old knowledge is dangerously important to pass on to those concerned. There are a million ways of teaching something, not all of them are good and not all of them are bad, being old or being young doesn’t matter, all the age gives us is perspective and understanding of how to pass on knowledge and whom to give it to.

By viewing the aspects of teaching, who needs to know what to be able to survive, complete a task or just continue living their life. Of what importance is all the facts, does one give the window of failure or does one give all the fact so that there is nothing left to learn?

Different generations

This might actually be a sensitive spot to touch, but I’ll be short in these words. There is actually a big difference between teaching 2 different generations. Imagine having a student which was born somewhere around 1960 and a student who was born 1980, depending on the age of the student and the age of the teacher, both these persons will take the information in two whole different ways.

If we would’ve taken me as a teacher example, I’m born 1987 which makes me not very old for being a teacher. Some of my students today are actually a lot older than me, which might give in to complications.

The different generations doesn’t only differ in age but in the attitude and the way of learning. A person born in the 1960:ies might have a harder time actually learning new things than someone born in the 1980, this is because, when this text was written it was the year 2008 which makes someone born in the late 1980:ies somewhere around 20 – 25. In this age, you have much easier to learn and take in new information.

Now this does of course not mean that someone born in the 1960:ies is stupid, rather that there are a big different and when teaching a group with a lot of different generations, this has to be taken into mind when planning a course.

Take another example such as a work place where your co-workers are much older, being young you rarely have anything to say on a work place where the stuff have been done in a certain way for very long.

So when trying to teach an older co-worker, you really need to sell the new information so that the older generation will be more interested.

But going back to the topic of teaching in a class room, it might be a benefit of being older, because older generations have much easier to focus and having a different mindset which will help them succeed.

It’s very important to respect each other, despite the age difference, if a younger person knows something that the older one doesn’t, it’s very important that the senior gives the younger person a chance to actually come forth and tell the information, that might in fact help production or whatever the work space might need.

Teaching differentials

There are a lot of different ways of teaching and what should be kept in mind when talking about different methods and where they apply is that everyone is different. I might not find it as amusing as you would, if I were forced to be taught with the old style teaching methods.

Thus, as stated in the upcoming topics, there are benefits of the both methods and there are of course a lot more out there, but the ones that you mostly see in action, would be these two.

Problem Based Learning

I would certainly say that PBL; Problem Based Learning, is my favorite method of learning. Ever since high school this has been a method that I’ve worked with.

The principles are that a student is given an assignment and there are known factors of failure which will somehow help the student learn what is necessary. After working with the problem for an amount of time, the solution will somewhat appear and the student has learnt something new.

There’s also another aspect of this, or rather, another explanation. Let’s take implementation of the sorting algorithm quicksort as an example. This is a fairly hard algorithm to master and it requires some base knowledge in the field. So when given this assignment, the first obvious part from the teachers perspective is that the student will somehow search for information about the algorithm.

Using internet or a special course literature, both should work very well. This gives the student an opportunity to master this assignment on his or hers own means.

When all the information is collected and the next phase in the learning process begins, which in a programming line of work would be to put up a structure of your software, in this case the software won’t be huge but having a pattern when working is always good, no matter the size.

As a result of this method, the student will have taught him or herself something new and by the individuals own needs.

Old Style Learning

As a matter of fact, the “Old style” in from my point of view might not be what you would suggest as an older style. And I am not talking about the old school tutoring where the teachers would be rude and make students learn by force and learn by fear.

In my eyes the old style would be where all the answers are somewhat given and there is no room for self teaching or in any way, a path given where the student can choose to learn just what is needed or learn so much more.

This old style can be seen at many high schools throughout, in my experience, Sweden. Now, the old style, what exactly defines this and are there any benefits? Well to start off, the old style learning method is where the students are put down at a desk, everyone directed to a whiteboard, and the teacher is using a pattern of teaching, where the pattern repeats itself. The old style pattern is when the teacher enters the room, greets the students, and starts talking and then when a question is stated an answer will be provided directly.

Now this point of view might be a little bit dull and it certainly has its good parts, they are just somewhat harder to find than the good ones in a problem based situation.

We have to keep in mind that everyone learns differently and that it’s important to give everyone what is needed to succeed. Thus, this method works in some cases but I would say that it wouldn’t work in most cases.

A benefit of the problem based learning system which the old one lacks is that you give a broader room for questions and thoughts and it’s fair to say that it requires a totally different mindset and maturity.

Which is best?

Giving an answer to that question would be somewhat impossible. Just not because everyone differs from each other so much, but in some situations I would also prefer to be tutored using the old style method.

The assignment stated in the PBL-example a couple of words back is a great example of how you can absorb new technology and new point of views. Programming itself is very broad and there are hardly any similar solutions out there. And the quicksort implementation sure is a defined structured algorithm but it can be implemented in so many different ways, it doesn’t matter if there are fewer rows or more rows, and they are just all different.

Which in the end would make you to consider how others are implementing it, what are the benefits?

Using the old style method, the tutor would just present some ways of implementing it and not giving you as a coder any room for own thoughts. A teaching method is always abstract in my eyes, you can’t tell someone to just go with a method, because “implementing” PBL differs from time to time.

Team work is important

You might think “What does Team work has to do with everything?”; Well actually team work has everything to do with learning. By being a tutor on various programming sections I’ve reached to the conclusion that team work is the most important part of learning and teaching. Now, team work isn’t all important only in the case of teacher to student teaching. This is also very important when we talk about teaching in a workspace.

Since I generally work as a programmer, the examples of programming workspaces suits me the best, so here goes. Imagine having a workspace where there are 10 – 20 developers, 5 graphical interface programmers and a couple of designers. These all parts need to co-operate for the development to work. If some of the staff has knowledge that someone else doesn’t, it’s very important that if this knowledge will help the company produce more, then this person needs to convey this to the rest of the staff. This is where the team work is important, if someone on the staff feels insecure with conveying the knowledge; this person is probably not right for the position.

I always say that when I work somewhere, I don’t want to be the brightest and the person with the most experience, this is because I want to learn, learning is very important and knowledge is worth a lot.

And if you’d come to a workspace where people is unwilling to co-operate, sure this workspace lacks team work and this will be disadvantage when you want to learn and grow professionally.

Sharing is caring

Not only does sharing rime with caring but it goes very much hand in hand, almost every time that is. In this case, sharing knowledge to your co-workers, students and family is very important. Especially when you work as a teacher, the sharing part is not only important but it’s a factor for you, keeping this job.

I’ve met teachers who felt threatened by me as a somewhat quick learner and bright student, not to sound too self-righteous this was actually a problem for me when I went to high school. I had teachers that, somehow, felt threatened by my knowledge and therefore didn’t want to share new knowledge with me.

This is a dangerous way for thinking and teaching, you always need to take the student, no matter if it’s a coworker or an actually school student, you always have to see the people you are tutoring new things, to be your student.

And a student is to be handled with care; your personality will in the end reflect in this student and will show everyone, how good of a teacher you are. Of course some people like to learn themselves, but, put your mind around this, initially how do you give someone inspiration? It’s by showing the person what skills you have and maybe how you’d do some things.

Sharing knowledge is in the end a vital factor for evolution, what if Einstein or other important people for our evolution, wouldn’t share their findings? How would this affect our current living environment and our current ways for thinking?

Feeding answers is dangerous

However, when sharing information it’s very important that you do this correctly. As mentioned in the previous chapter, all people learn differently. This is probably one of the hardest parts by being a teacher; you need to find a common spot which almost all students like.

Of course this is often impossible, thus there are more than one path to take and there are almost always presented two or more ways for the students.

One important thing to always keep in mind is that you can never ever just give out an answer to a question without somehow providing a solid explanation or a proof why it works.

Why you might ask, this is because when being a student, you are almost certain to always take the easiest path and not thinking clearly about consequences. By being spoon feed you will never really care about how or why the solution is what it is.

And being a programming tutor, this part is very important, what if I were to give all the students the correct answers to all assignments, and tell them “Here are the answers, go find out why”. Maybe a couple of percent would actually find out why the answers are as followed but the majority wouldn’t. So to keep in mind is that when a solution is presented, always give out a good and pedagogic explanation to why.

This topic actually doesn’t just apply to students, it’s also very important not to just give co-workers the answer and let them be happy about it. I know that sometimes I just want a quick answer, but when I actually encounter the problem the second time, and not knowing how to solve it, I regret not doing more research the last time.

Giving inspiration not motivation

Not to feed answers and giving inspiration is actually something that we can see go hand in hand. When you actually want to teach someone something you want to give the person inspiration and give them the mindset of wanting to learn.

So why wouldn’t you want to give someone motivation? Motivation isn’t something that can just be handed out, actually motivation is something that I would say comes hand in hand with inspiration, when someone is inspired, the motivation might peek and giving coworkers and students inspiration on a regular basis might in fact help the persons succeed and somehow indirect force them to teach themselves.

When open source helps programming tutors

Talking about open source could be a completely separate paper and take up many pages of explaining why this is a good way of learning and working. First of all, what is open source? Open source is a way for providing your product open and free, not only the software itself but also the source code, which defines the business logic, the graphical programming and other aspects of the program. This is a definition from Google on open source:

A program in which the source code is available to the general public for use and/or modification from its original design free of charge.

This is actually interesting, companies, people and organizations giving out their source code for free, so how does this actually help a learning process? Well for starters, there are software available for development and making office work more easy and there are so many softwares out there that can and will help you learn new ways.

The topic on open source now is very programming tutoring oriented and might not really be of interest if you work in a construction site. But think of it like this, what if there were some free ways to actually make your construction work easier?

When teaching programming we often come to points where we do reference an open source project, Linux is one of those; Linux is a kernel for the GNU / Linux operative system. This kernel has from the start been open source and the community which uses it has always been very helpful and made this a better product.

Now, working on a project like linux might not be very easy, but it does in fact give you knowledge, this is an very important time to take up that you always have space for new knowledge and you are never too old to be learning new things.

Programming on linux or any other open source projects might require that you actually have some experience from the start but you will also gain so much from being a part of this process.

The post The Art Of Teaching appeared first on Filip Ekberg's blog.

The following article is an article that I wrote duing my studies for a bachelor degree in Software Engineering. Minor changes might have been made to make it more suitable on this website.

Both my experience and writing style has changed since I wrote this article, but I still want to share my thoughts from 4 years ago.

Let me know in the comments below what your most common project startup difficulties have been!

Abstract

There are a lot of usual suspects in the terms of risks, problems and other aspects of failure that you need to take in mind, worry less about the customer and more about the communication. This is highly important for success; you must find your way of communicating.

Be prepared; There will be problems

In the writing moment of 2009 I am currently in a development project of which I have the benefits of being System Architect. Having this position in a project is not something that is totally new to me; in 2008 I had the same benefit.

This experience of mine will be used as a reference point, so keep in mind that my points of view is not strictly from a developers eyes. Being the System Architect you have a lot of responsibility such as keeping track of each developers work process, extending each person’s views of the project and being a leader which never falls apart.

Starting a project, not just development projects but generally speaking you face a lot of common problems; team-work issues, financial issues, third-parties, customer issues and many more. I will not focus on the financial issues because the project we current work on is strictly, as they would say in the world of lawyers, pro bono; which is what we mortals would call free.

So not having to worry about the financial problems, we can focus more on the other areas, which in my eyes actually does cause problems and have as it does in many cases, caused problems in our project. Problems don’t always mean that the project fails or that everything falls apart, it just means that we have something to handle. We also have problems that are planned or more likely anticipated more than planned; a planned problem would be fixed before it became an issue.

The usual suspects

As mentioned in the previous part there are a couple of problems that you might anticipate in your project. There is no common solution that’s widely used on all projects. As a lot of other things in this world; things are different depending on the situation. This is the case of projects as well. I will merely give an overview of what could be expected and how I would like them to be handled.

Team-work issues

Reflect over the following; is there anything like perfect team-work? I once said: Team-work comes from willing to cooperate it is not something that can be forced. It doesn’t matter how different you are; as far as we know, everyone is different. I would like to say something like: just work together, what is the problem?

However that statement is bold and doesn’t apply to reality. As mentioned earlier I work in a project, the project consists of 9 other developers where 7 of them are security experts and two of them are, just as me, software engineers. If you look closely enough you can see that there are a couple of things on both sides that resemble a similarity. The security experts have one way of solving problems and the engineers have another, what we need to achieve here is a common ground of both problem solving and the way of communicating.

Our project started out great, there were no direct flaws in the team-work, all parties liked to work together and we solved communication and other future problems very fast. However, as the project has evolved so has the teamwork, but has it evolved enough? As there is no direct answer to that, I can only speculate on the different outcome of today’s progress if we would’ve evolved more with the project.

As of the beginning, there were no issues with the team-work, we did not even argue about small things which can be a big problem in many projects. However as everything evolved and third-party problems came in place, we did come to the stage where we had to raise voices and stand ground.

Not all projects start out with a nearly perfect chemistry between its participants. And maybe it would be for the better to argue it all out in the beginning, finding all these communicational problems from the start and work from there? The outcome from our project is that you start to take things for granted, which is a dangerous path to take.

Customer related issues

The first thing that really comes in mind when I write “Customer related issues” is a direct link to money. No matter how you bend on in, when it comes to the customer, it’s always a matter of money. As for our project, this is somewhat a problem as well. Now, you might recall that this project is what we call it “pro bono”; free; gratis. So, what could possible be customer related that has to do with money? Well in our case the customer buys hardware for us, which they want to be further developed, this hardware is in a development stage and therefore not well documented. This means that we need to contact the producer of the product to get information. However, the producer being one of the world’s biggest companies; they do know when to ask for money.

Now this gives us a big problem, since the project doesn’t have any revenue we can’t afford this, so we need to ask our customer to pay for this. This results in a great problem;

• The customer places an order
• The customer expects everything to be done according to plan
• The customer is expecting everything free of charge

Now, the last two stated points above in the work-flow is where our problem is. Is there a solution to this? The project could be delayed, we could be put up in a workpool for other projects to gather resources from meanwhile the producer evolves the product and set up a proper documentation for it. However, we don’t have that time, so what has to be done is either brute-forcing the system gathering all information possible to solve it, or we ask the customer to pay for the education needed by the producer.

In our case the customer actually paid for this education, because this product is very important and scheduled to be delivered and sold after the summer 2009.

There are however a lot of problems not related directly to money, you can see these other problems a lot in the IT Consulting business where I usually work;

• Non-cooperative customers
• The all-knowing customer
• The non-paying customer
• The customer who says one thing and the customer who wants something else

I’m going to state something that many would disagree on; never trust the customer. You might get a surprised face when reading that, but in fact you should trust anyone than yourself; if you can even do that.

Now this is becoming fairly abstract but stay with me on this. If you really think about it, if you start trusting people you suddenly start relying on others to do what they say, always assume people are going to be late and if the customer says “How long will x take to develop?”; The first ting you need to think about is, does it take T hours? Does it take T – 100 hours? What’s the most accurate time? Before you say that, add a factor of 2. So, why add the factor of 2? Because you always over-estimate your skills, you might think that it takes 10 hours, but it takes 20 hours or even thirty hours. If you over-estimated and said for instance 50 hours, and it took only 25, your customer will be very satisfied. But if I take 100 hours and you said 50, you will have a big customer problem.

Managing the Team to avoid these problems

A great leader is one that makes the workers think they are doing everything that will benefit themselves. In my eyes a project manager is, or should be, very much like a great dictator; A great leader. If you were to revise the book The Deadline3 you would see how they speak of their mangers and what really makes a good project manager. Some of the points that you would consider is:

• The co-workers speaks well of you
• You are considerably good at understanding people
• Not scared of taking chances
• Risk your job every day

As a project manager you might need to risk your job every day, this meaning that you must do things that will benefit the group or the project in longer terms but might not be so good for yourself in the current situation. Managing a software project is just a game of risk management, if you were to find all casual risks and manage them, what else would there be to worry about?

The post Project startup difficulties – The usual suspects appeared first on Filip Ekberg's blog.

Basically what has happened here is that all the roads are full with cars and all the cars try to cross the road at the same time. Let’s translate this into computer terms; the cars in this case are the threads and the cross-over is the “thing” that handles these threads. In the illustration above all the cars have driven into the cross-over at the same time and they can’t really back up, hence there’s a deadlock and there’s no way to go.

What happens in a computer program when you get a deadlock is that it freezes and there’s no where to go because all paths are occupied or waiting for something to finish. Let’s say that process X waits for process Y and process Y waits for process X and both of these lock up the GUI thread, this means that the application will die. Hence deadlocking is something you want to avoid.

Normally you solve this by introducing locking and semaphores. As discussed in the article linked above (where I got the very nice illustration) a semaphore can be seen as a traffic light which handles how the cross-over is loaded with cars.

A while back I wrote an article called “Avoid shooting yourself in the foot with Tasks and Async”, I suggest that you should always return a Task from your asynchronous methods and you really should. What I am about to tell you below though is what you should avoid when doing this.

When a method is marked as asynchronous and the await-part is reached, the method will “exit” and return the “awaiting Task“, which means it’s not the Task that runs inside the method but in fact a Task that keeps track of the status of the asynchronous operation.

Let’s look at a basic code sample!

Consider that you have the following basic asynchronous method, all it does is that it waits for 2 seconds and then prints something to the debug window:

Once await is reached, what will happen? A Task will be returned, but which one? Not the one named run! A Task that keeps track on the state machine will be returned.

Now what happens if we call this method on the GUI thread and asks to wait for it to finish? Calling Wait freezes the current thread and since we are on the GUI thread this will freeze the GUI thread, but for how long? When is Wait happy enough to proceed? In fact it will wait for the asynchronous task that handles the state machine to give it a signal that it’s now ready.

However that Task can never be marked as done until the entire method has been completed. Which means that it needs to access the GUI thread again, since we’re back on the calling thread (GUI thread in this case) after await!

This means that all we have to do in order to deadlock is this:

I hope that makes sense to you and gives you an insight into what really happens when you use async and await. As with everything: use it wisely and know what it is that you’re doing.

I’d love to hear about your deadlocking stories!

The post Don’t deadlock with async and await appeared first on Filip Ekberg's blog.

Another problem is that if we do decide to log errors in our applications, where do we store them and how do we collect the logs? Luckily there’s tools out there that can help us on the way. One that I most recently came across called Raygun. Raygun is a product from the company Mindscape that have some very interesting products in their family.

Error handling just got awesome!

The punch line of Raygun is quoted above, a tool that makes error handling awesome. Let’s clear something up right before we take a look at Raygun , there are multiple providers supplied for Raygun: JavaScript, .NET, Java, PHP and Cold Fusion. Didn’t find the language you work with? Don’t worry, there’s a REST API for you RESTafarians!

So there are providers for Raygun, but what does it actually do?

Imagine that you have your web application written in PHP, ASP.NET or just something that is using JavaScript. Now you want some centralized place where you can store errors in either of these applications, be it severe exceptions or just notices about something unexpected.

If you’ve found yourself writing an error tracker where you just dump the Stack Trace and the exception message into a database, then this is certainly something for you. Imagine that if your customer calls up and says that he recently got the yellow screen of death but don’t know what he was doing or really exactly what time it was.

Now imagine that you were to access your centralized error tracker and you’d have all of the information that you would need to find the error in the code base including:

• Time of error
• How many times the current error have occurred
• Information about the system the user is using
• The exception message
• A Stack Trace

That is Raygun! A way to track your errors in a very easy way and the presentation is just beautiful.

The information you’ll get out of each error report of course depends on the data that you supply Raygun with. Take a look at the REST API to get an idea of all the data that you possibly could supply Raygun with.

Enough with what, let’s look at the how! Let’s look at some code!

For this demo I’m going to setup 2 things an ASP.NET MVC 4 Application and a Class Library that will simulate a data store where I can search for people. The web front will allow me to search for people inside my collection and when I wrote this example Raygun actually helped me detect one of the errors I were getting, let’s call this “TrackCeption”.

First of all let’s look at the library. There’s a very easy class that represents the person, it simply has a property called “Name” inside it.

Secondly there’s a class that handles the search requests, I call this RequestHandler. To set this up we need to create a new list of people, in this case it’s just going to be a static collection of people as you can see here:

Now we need a way to retrieve all these people and I like creating asynchronous methods where the operations might be time consuming and in this case I know that it will take 2 seconds to retrieve the list of people:

This leaves us with implementing a method that lets us search for people in the collection. So far we don’t care if the list has been empty or not but when we search we want to report an error when there’s no people in the list. Let’s just assume that this is an exception in the application and the end user will always search for people that are in the list.

Let’s install Raygun!

Installing Raygun is as easy as saying “I’ll soon blast all my errors with this Raygun!”; simply bring up the NuGet package manager and write the following:

This will install Raygun into your class library! There’s a couple of more things that we need to do in order to get Raygun up and running:

• Create an account and an application at Raygun.io
• Add the API Key to your application

Creating a Raygun account is free for 30 days and you’ll need to do it in order to start tracking your errors. Once you’ve setup an application on Raygun you can retrieve the API Key from the “Application Settings” menu like you can see in the following image:

We don’t need to add the API Key just yet, we’ll add that in the application configuration file of the project that will use our library later on (in this case the MVC 4 project).

Now, bringing in Raygun into our application using NuGet will allow us to write the following:

That will create a Raygun client and send a new exception with the message you can see to the Raygun servers and passing it the API Key that we will provide later on. So let’s take a look at how the method that will find people in the colleciton will look like. This one also takes 2 seconds to execute so we will have this one asynchronous as well, we don’t need to do it but I take every chance I got to play with asynchronous programming.

The method will look for people with the name of the value that we passed to the method and if there’s no people found it will send this notice to Raygun. You might think to yourself that this isn’t really a good exception at all, but for the purpose of the demo, let’s just look pass that. Also a bird whispered into my ears that Mindscape is working on adding other message types than exceptions to Raygun, but that’s in the future.

This leaves us with a structure looking like the following:

We are now ready to use our library!

Create a new ASP.NET MVC 4 Application, I named mine RaygunDemo. The first thing that we are going to do is to add Raygun to this project as well, install it into the ASP.NET MVC 4 project using NuGet as we did before and open up web.config once this is done.

In order for us to get Raygun working we need to add our API Key. To do this we first need to add an element inside <configSections>:

This will allow us to add a configuration like this:

It should look something like this in your web.config, with a lot of extra stuff as well of course:

Remember I said that Raygun helped me find an exception in my application when setting up the demo application? This is because I told Raygun to submit all the application errors. In the ASP.NET MVC 4 project, open up Global.asax and add the following method, this one will be run every time there’s an error in the application:

This means that every time that we get an application error Raygun will be noticed of this and the entire Stack Trace, Computer info and such will be passed into Raygun!

All there’s left to add now is the Home controller and the view, the Home controller consists of two asynchronous actions that will use the library we just created. One will return a view and the other will return a Json result:

The view is equally simple, it only has a text box that allows us to search for names and then it has a list that shows all the people. Once a key is pressed inside the text box an event is fired that requests the people that have a name containing that part:

If I start this and search for a name that exists and one that doesn’t it will look like the following:

Funny thing is that we didn’t actually notice anything when we searched for something that didn’t exist. So how do we know that this worked?

Raygun comes with an Amazing dashboard that will give you an overview of everything including all the recent errors, how many errors/ignored errors you have and much more like you see in this image (click to enlarge):

Finally this is what it looks like when you go into details about an exception, you’ll have a graph over how many times and when it occurred and then you have very much details that will help you Raygun the errors!

If you’re unable to add code to your current website you can simply add a HTTP Module and a config value! Which means you could simply add this in your web.config provided you have the dll as well of course!

I really recommend giving Raygun a try! Let me know what you think of it and if you have any alternatives that are equally awesome!

The post Easy error tracking in your applications appeared first on Filip Ekberg's blog.

We always have interesting discussions at work, both philosophical and mostly programming discussions. Sometimes the things people say make you think a while longer.

The other day a co-worker of mine asked me:

If a tree falls in the forest and no-one is there, will anyone here it?

I quickly responded with this:

No, no-one will hear it but it will still make a sound.

The fact that it will make a sound is proven by science but that’s beside the point. It’s a trick question that leads you to say “No” but if you view the problem differently you’ll soon have a pretty good answer.

While my co-worker was stunned and rather mind blown by my fast and quite accurate response, I think that most of us developers think logically about most of our problems and try to see solutions to puzzles much harder than this particular one.

If we look at problems from more than one perspective and think about all different outcomes, we can and most likely will do better solutions.

I felt kind of smart for a moment there, don’t you just love that feeling?

When it comes to software engineering I try to think outside the box as much as possible. For example I reflect over the following:

• Is there anything I can do to increase the value to the customer in a timely fashion?
• If we spend X amount of time refactoring this, how much will we have saved in the long run?
• If the visitors of the website will never use a mobile device, is it a smart move doing a mobile version?
• Is the problem parallelizable?
• Can we add asynchronicity to increase the end user experience without messing up the code?
• This new feature in .NET seems very cool, but will it add value to the product? (Most times, yes!)
• What can I do to decrease the memory imprint of the algorithm?
• Can we use any patterns to make the solution more solid and less error prone?

Do you take the time to think outside the box?

The post Seeing problems differently appeared first on Filip Ekberg's blog.

So I said yes to this half marathon and as I am a very determined person I am going to finish this race, no matter what time or in what condition; I am going to finish this race!

Here’s why: I believe that challenging yourself over and over again will make you challenge yourself out of habit in the end. This might sound weird but think of it in engineering terms instead. If every day that I sat my foot at work, no matter if it’s for developing trivial tasks or not I would challenge myself into writing one better line of code than the day before. Or even better, I would challenge myself into going back to the previous days work and improve what I had then developed.

In the long term challenging yourself will make you question your solutions and you’ll start to think if this way is the best which ultimately will make you do very good solutions from the start; but there’s always room for improvements! It might sound like a cliché but frankly I think too many of you forget to challenge yourselves or rather you forget to ask or take the time to do so. A friend of mine told me that he tries to optimize his coding performance so that he will output high quality code in a shorter time period so that he then have time to go back and refactor pieces of the solution. This is exactly what challenging yourself helps you do: Improve, Improve and Improve!

In the end, don’t we all just want to be awesome at what we do? No matter if it’s software engineering, running, catering or anything else for that matter?

Tomorrow when you get to work challenge yourself into something like the following and tell me how it felt:

• Refactor a method that you wrote this week that you’re not entirely happy with
• Find a class, method or property that you feel needs to be explained better and add a comment or rename it completely
• Dare to make a breaking change for the better of your product
• Ask your boss for a license to ReSharper, JustCode or any other productivity tooling

Personally if I hadn’t challenged myself into doing things that scares me I would never had stood in front of a group of people talking about programming, I would never have written my book and I would never have started my own company.

You can be awesome if you just put your mind into it, remember that you’re just as awesome as you see yourself.

There’s a chapter in my book called “Creating a challenge out of the trivial tasks”, the ebook is currently available for €4.99!

The post Challenge yourself and be awesome appeared first on Filip Ekberg's blog.

Pursuing programming as a profession is a completely different subject.

Every programming job that I’ve had have been different, some jobs required me to work more than 40 hours per week and some jobs somewhat had a clock that we clocked-in with and only worked 8 hours per day on weekdays. However a lot of programmers don’t leave their work at work and frankly their personalities aren’t programmed that way. I for one love exploring new things, I love writing about technology and doing as much programming as my personal life lets me. Everyone is different though. I know a lot of programmers that don’t want to live like that, they want 40 hour weeks and that is fine; it works very well for them.

In the video “What most schools don’t teach” everyone started programming before they hit 10 years old, which isn’t at all required for you to work professionally with programming. I know talented programmers that started working with programming in their late 20s and when I worked as a teacher for a programming education we had students that were close to 45. It’s never too late. I even read an article a while back about a man around 85 years old that recently learned JavaScript and he loved it!

Everyone Should Not Work With Programming. But that doesn’t mean everyone shouldn’t Learn Programming.

I program because I love it and when I started working with programming the money was crap but I still did it because I loved it.

What most schools don’t teach

The post Everyone Should Learn Programming appeared first on Filip Ekberg's blog.

A good example is how language features for asynchronous programming were added in .NET 4.5. But asynchronous programming was possible before this. “All” it really does is adding a nice state-machine and does all the heavy lifting for us. This is something that developers doing asynchronous programming would have to implement over and over again thus making it a perfect candidate to become a language feature.

Mindscape has an article about what F# features every C# developer should lust after which brings up some interesting language features such as:

• Pattern matching
• Immutability
• Object expressions

What language features do you miss in C# and why? Keep in mind that a language feature should target a broad audience! Maybe you’re happy with what is in the language right now?

C# Smorgasbord ebook limited-time offer now only €4.99!

The post What language features do you miss in C#? appeared first on Filip Ekberg's blog.

Want to peek inside? Sample available!

There’s a “Look Inside” available on Amazon!

About the book

Looking at everything from testing strategies to compilation as a service and how to do really advanced things in runtime; you get a great sense of what you as a developer can do. By taking his personal views and his personal experience, Filip digs into each subject with a personal touch and by having real world problems at hand, we can look at how these problems could be tackled.

No matter if you are an experienced .NET developer, or a beginner, you will most certainly find a lot of interesting things in this book. The book covers important patterns and technologies that any developer would benefit from mastering.

Table of Contents

• Introduction to Parallel Extensions
• Productivity and Quality with Unit Testing
• Is upgrading your code a productive step?
• Creating a challenge out of the trivial tasks
• Asynchronous programming with async and await
• Dynamic programming
• Increase readability with anonymous types and methods
• Exploring Reflection
• Creating things at runtime
• Introducing Roslyn
• Adapting to Inversion of Control
• Are you Mocking me?

Enjoy the read and spread the word!

Want a printed copy?

There’s a discount on that one too!

Discount code: N9UV3WDP

The post C# Smorgasbord ebook limited-time offer now only €4.99! appeared first on Filip Ekberg's blog.

Let’s assume that we have the following code that declares a delegate and a method that uses it:

Now consider that you want to run this method and pass a method for it to execute that corresponds with the delegate. The process of running this will be in a loop that runs for 10 000 iterations.

The method we want to run is called Foo and looks like the following:

Everything is set up, so what is it that we need to optimize when calling this 10 000 times? Well we have two different ways of using the method with a delegate.

Option 1
The first option is that we can use an anonymous method to call this method looking like the following:

If we compile this and open it up in Reflector to see what is generated, there’s also some other stuff generated behind the scenes but this is the important part:

Looks good so far, right? Let’s take a look at Option 2 and compare.

Option 2
The second option that we have is just writing the method name to tell it to use this like you can see here:

This one is quite common and I’ve seen it used a lot, but what happens behind the scenes here?

If we open this up in Reflector we can see that the following code was generated:

This is significantly different from the lambda one! Is your mind blown yet?

Ok let me break it down, it’s quite simple. What happens with option 2 is that it will create 10 000 instances of TestDelegate and thus using a lot more memory. The lambda version was optimized but the “normal” one wasn’t?

Let’s just verify that it actually does use a lot more memory! I’ve set the solution to compile in Release mode with Optimization turned on and I’m using the following code to test it:

Here’s the result from that operation:

Conclusion

If we use delegates “wrong” or don’t think what code is actually generated this can leave us with large memory imprints. Of course you always need to think about the code you write but in some cases you might not really know what the compiler ends up doing.

By using the lambda version instead in this case we’ve avoided to create a lot of new delegate instances and thus minimized the memory imprint.

Fun fact: If we compile the “normal version” using MonoDevelop and Mono (2.10.9) it results in the same output. Which leads me to think that this is by design. The only difference is when we compile the lambda version but nothing significant that changes the behavior at all.

Do you say this is a bug or a feature? Did you know it behaved like this?

The post Optimize your delegate usage appeared first on Filip Ekberg's blog.

The following image illustrates what happens when we compile something, we put the C# code into a basket and tell the compiler to give us a binary of this which is sort of a black box at the moment. We know that whenever we want to use this black box we have something behind the curtain that knows how to open it and use it properly (read: CLR).

Let’s consider a basic variable instantiation and an equality check, when this is compiled it will output something partially readable. To me the output is readable but that’s just because I have a weird love for IL. When this basic snippet was compiled using LINQPad it generated some IL which you can see below.

Imagine that you got a DLL from an old co-worker and the code is long gone but you need to make some changes to the code. What do you do? One option is to mimic the functionality if the application is not too big and create it from scratch but that is just cumbersome. Instead what we want to do is something like you can see illustrated below; we want to go back from IL to C#!

So how do we do this? By using a decompiler!

As I tend to do this quite often to understand how libraries work that I have no control over, I have tried some different tools for just this cause. Let’s take a look at four of the most common ones on the market. Don’t worry, there’s both free versions and paid ones out there!

Telerik JustDecompile

The first one that we’re looking at is a product from the Just* family created by Telerik. I do like the products from Telerik so this one should be quite interesting!

JustDecompile is completely free and available for download over at Teleriks website. One thing that I didn’t like thought was the installer, generally Telerik’s installers are pretty nice, but I don’t like being “guided” to install other stuff than what I’ve asked for.

Below is a screenshot of the installer and as you can see it advices you to install a lot of trials for other Telerik products.

After selecting only to install JustDecompile the installation will only take up 36MB. You’ll also need to create a Telerik account if you don’t already have one which can also be a hassle, but it’s free so why not!

I’ve setup a project that has the same variable declarations and the equality check from above and then compiled and opened the executable in JustDecompile. The result is quite similar to the original source as you can see in the following image.

We can also select to show the result as IL instead of C# code!

There are a couple of things that I didn’t find straight forward using JustDecompile.

Pros

• It’s free!
• It’s fast!
• The UI is beautiful
• It looks easy
• Does what it should (partially)

Cons

• There’s a button for creating a project, I expected it to be able to export my binary to a complete VS Solution but it’s grayed out and there’s no tooltip on why that is so.
• Showing the source as VB instead of C# shows nothing at all, shouldn’t matter if the original code was C# or not.

JustDecompile Summary

Even though there are some cons; would I recommend you using it? Of course! If you haven’t installed it already go ahead and do so! It can only become better if more people support it and give them suggestions. There’s even a suggestion button where you can submit requests.

ILSpy

This one is interesting, ILSpy is an open source assembly browser and decompiler for .NET Applications! This means that if you don’t like what it does or if you have feature suggestions, “you can just” provide the fix yourself! The tool itself is equal to what JustDecompile offers but the installation process is much easier. You simply grab the binaries or source from the ILSpy website and unzip it wherever you want it!

I simply performed the same process as I did with JustDecompile; I started ILSpy and opened up my executable but this is where it gets interesting. The code that it decompiles to looks Exactly like the code that I wrote in Visual Studio as you can see in the following image.

Decompiling to VB also works right out of the box, this tool has what it takes!

Now to the more interesting feature; Can we save/export this to a C# Project?

By the looks of it there’s a “Save Code” action in the File menu, selecting the assembly and then pressing ctrl+s or the “Save Code” action actually lets us save a csproj file! If you open up the location in your file explorer you will see that it actually generated a project file and the code file!

I think we’ve looked enough at ILSpy to write up a pros and cons!

Pros

• Free!
• Open-Source, do I need to say more?
• All features seem to work as they should
• Easy to use interface
• Fast!

Cons

• The UI isn’t really that good lookig but it’s functional
• The application seemed to freeze once but it just took a while to analyze a code file, I had to stretch for this one..

Summary

There really aren’t many bad parts regarding ILSpy, I like it but if I have to complain about something it’s the UI and that it felt like it froze once. I really recommend trying out ILSpy and looking over the code for it, it’s great for educational purposes and I have co-workers that use it all the time and like it a lot.

What are you waiting for, go download!

dotPeek

Just as the two mentioned above dotPeek is available for free, it’s not open source though. dotPeek comes from JetBrains and is available on their website where you can also find a lot of interesting information about how to use it.

Installing this is easy and doesn’t force you or ask you to install anything else than what you really want in this case.

If you are familiar with ReSharper (R#) which is also a product from JetBrains, the keyboard shortcuts will be something of value to you. In fact dotPeek uses the same navigation as you might be used to from using ReSharper!

Let’s have a look at what dotPeek thinks of our executable. When opening up dotPeek you’re meet with a beautiful interface that feels like it’s a part of the Visual Studio family (except for the very colorful icons). Opening up the executable and looking at the code you can see that it didn’t really give us the same result as any of the other decompilers we’ve looked at.

So instead of actually displaying what the IL tells us, it analyzes the IL and optimizes the code for us which is really not what we want to do. There’s also no way of swapping between C#, VB.NET, F# or IL. So in this case we are “stuck” with looking at some C# code without knowing what IL it comes from.

What is also a downside to this is that you cannot export the code that you are looking at, which means that this is a pure code browser.

Pros

• Beautiful UI
• Fast
• Code inspection and navigation that you might be used to from ReSharper
• Supports plugins just like ReSharper

Cons

• Lack features such as show code in different ways; swapping between VB.NET, F# and IL
• Doesn’t resemble the actual code that was compiled
• Doesn’t support exporting code or projects
• The application itself seem to be very light-weight and lacking configuration possibilities

Summary

While I like JetBrains products in general, this one feels like there’s something missing. Personally when I use a decompiler I want it to be able to show me the output code in different ways and give me options to export it. But if you are looking for an assembly browser that decompiles to C# and just does that, this is perfect. Even better if you are used to ReSharper, you will certainly find the keyboard shortcuts for navigation handy.

.NET Reflector

Last but not least, my personal choice .NET Reflector! I’m not really sure why this is my personal favorite but keep on reading and you might find that it’s because the mixture of good functionality with a common and easy to use UI.

.NET Reflector is available by RedGate but costs money which is maybe why it’s “better” than the alternatives. This wasn’t always the case though once upon a time it was available for free. I was lucky enough to win a free license a while back so I’ve been able to use it quite a lot. You can buy it or grab a free trial over at RedGate’s website.

The installation is easy and doesn’t try to force you to install a lot of other things that you don’t expect. .NET Reflector comes with a Visual Studio extension that will let you use the features in Visual Studio instead of starting a new instance of .NET Reflector.

Just as with JustDecompile and ILSpy I opened up the executable that we looked at before and as expected it shows the same result as ILSpy does!

As you can see here the UI is quite minimal and easy to understand. What is interesting here is that it also allows us to view the code as F# code as you can see in the following image.

If we want to export the code that we have just as we did with ILSpy we can right click the assembly and select “Export source code” this then asks us where to store it and gives us information about the exported files. As you can see in the two following images it exported more files than ILSpy did.

And the resulted files look exactly as we expect them to, the code file has the same code as we did in the original source code.

Pros

Cons

Summary

The costs is the only downside that I’ve found during my time using it which means that if .NET Reflector was free tool for Decompiling .NET Applications it would be the number 1 choice. It isn’t free and the cost must be factored in when comparing the value of the product.

Conclusion

If I hadn’t won a free license for .NET Reflector I probably would have used JustDecompile or ILSpy as both of them are very good tools for Decompiling .NET Applications!

We’ve looked at how we can decompile applications and browse the code in different ways when only having the executable available. This also works with libraries in the global assembly cache.

Looking around in the .NET Framework to see how they’ve done certain implementations can be great for educational purposes but using this at work to understand how someone implements a certain feature can be priceless.

I hope you’ve found this read interesting and that you’ll be digging deeper with tools for Decompiling .NET Applications. Let me know which one is your favorite or if you’ve used another tool than the four mentioned above!

The post Decompiling .NET Applications appeared first on Filip Ekberg's blog.

I’ve also written about Roslyn in my recently published book (which is currently on a discounted price!), be sure to check that out. For your information the book is available in Print, Kindle, PDF, ePub and Mobi; the three last ones here are included in a purchase of the printed copy!

Watch the below presentation and let me know what kind of ideas you get based on it and also let me know if you like it or not!

Enjoy these 50 minutes of Compilation as a Service with Roslyn!

The post Compilation as a Service and the next generation plugins appeared first on Filip Ekberg's blog.

The feeling I got when receiving my first proof copies of the book is indescribable, it was pure awesomeness and this feeling is almost as great. It makes me very happy that so many developers have decided to get a copy of C# Smorgasbord, thank you all very much for that. All the great feedback and the amount of copies out there are the basis to why I want and can have these giveaways!

Now to the winners, I know that’s why you’re here anyways. As the giveaway was re-published on DZone I’m going to include those comments as well. Thanks everyone that participated and I really hope that if you didn’t get a free copy this time, you’ll enjoy the discounted price found at the end of this post.

The winners are:

Sergio with the following comment:

Checking the content this book has, it would be a good reference to create great architectures using advanced techniques like Reflection or runtime thing creation. It also shows last features of .Net framework so it will have good examples of how to understand them (I honestly can’t understand async :$ and no good Spanish doc, besides that, I have no credit card to buy the book ) I read about the book on this Hacker News’s link: http://blog.filipekberg.se/2012/07/21/c-smorgasbord-will-soon-be-available/
(I said: “I need that book!!”)

Adam with the following comment:

I would like a copy of your book because everything i learn from it will go onto my blog hopefully passing knowledge onto many others.

I feel your book will fill in various gaps in my knowledge, and will hopefully help secure that senior developer position and finally, i mentor the other developers around me and the junior developers, and this book will be an excellent resource, and with titles such as “Creating a challenge out of the trivial tasks” will hopefully help inspire the developers to take pride in even the trivial tasks.

Henric with the following comment:

Don’t leave a former Sigma colleague hanging! I’ll give you a blog post reviewing the book (on my massive 2 visitors a day blog) and I will spread the Smorgasboard love to current co-workers.

Stay awesome!

Daniel with the following comment:

I would like a copy of your book, because I think this would greatly benefit my student project in which we are creating an application where stuff can be augmented and moved / edited with simple gestures Right now much of the code is hacked together, because no one in the group used C# before (the university teaches java ), what leads to “not-so-good” performance and way too many bugs! I am responsible for the code quality and C# teaching and the book would help me to be more helpful to the other guys.

Malte with the following comment:

Finished my CS degree last summer, and got a job as a software developer, primarily C#. I try to improve my programming skills every day, and found this blog and blogpost through the “Interesting Finds” blog series from Jason Haley.

Hadn’t heard about your book, but after reading about it, it seems very “hands on”. And i would love to read it.
I find it especially awesome that you self-published the book

Congratulations on winning a free copy of C# Smorgasbord, I hope you enjoy it and help others become better programmers as well!

Now to those of you that didn’t win a free copy. I’ve setup a discount code that can be used on CreateSpace (this is where the book is printed) and this will give you a 35% discount!

Use discount code N9UV3WDP to get 35% off here (takes you to CreateSpace)!

Pssst.. if you don’t want to wait for the printed copy to arrive due to (sometimes) long shipping, you can get the ebook the same day as you purchase the printed copy! Just fill out this form.

Enjoy the read and spread the discount code to anyone and everyone!

The post Congratulations to the winners of a free C# Smorgasbord copy! appeared first on Filip Ekberg's blog.

I want to win a free copy!

Unfortunately I can’t give everyone a copy of the book so if you want to win a free copy of C# Smorgasbord, all you need to do is follow the two steps below:

1. Leave a comment down below with the reason as to why you should be the lucky winner. It’s a bonus if you include why you like to read this blog.
2. Share this post with your friends on twitter: Tweet it!
   

The best motivation wins and the winner will be notified via e-mail, so be sure to leave your e-mail address when you’re commenting below. You’re e-mail address will never be visible to anyone else than me!

That’s it! Good Luck to you all!

The draw ends February 1 (6pm CET) and all comments will be published once they’ve been received

What’s C# Smorgasbord?

C# Smorgasbord covers a vast variety of different technologies, patterns and best practices that any C# developer should master.

Looking at everything from testing strategies to compilation as a service and how to do really advance things in runtime; you get a great sense of what you as a developer can do. By taking his personal views and his personal experience, Filip digs into each subject with a personal touch and by having real world problems at hand; we can look at how these problems could be tackled.

No matter if you are an experienced .NET developer, or a beginner, you will most certainly find a lot of interesting things in this book. The book covers important patterns and technologies that any developer would benefit from mastering.

Is there a digital version(ebook)?
Yes there is! Everyone that purchases the printed copy will get the ebook for free. Instructions for how to receive the ebook is inside the printed book.

Table of Contents

1. Introduction to Parallel Extensions
2. Productivity and Quality with Unit Testing
3. Is upgrading your code a productive step?
4. Creating a challenge out of the trivial tasks
5. Asynchronous programming with async and await
6. Dynamic programming
7. Increase readability with anonymous types and methods
8. Exploring Reflection
9. Creating things at runtime
10. Introducing Roslyn
11. Adapting to Inversion of Control
12. Are you Mocking me?

Who this book is for
This book is for those developers that find themselves wanting to explore C# but do not know how or where to start looking. Each chapter contains hands on code examples that can be compiled and tested on your machine.

Although each chapter has code samples, you do not need to use a computer to appreciate the content of this book. The code samples are divided into smaller portions of code, so that you can follow each example and the thoughts around it in an easy way.

No matter if you are an experienced .NET developer or a beginner, you will most certainly find a lot of interesting things in this book. The book covers important patterns and technologies that any developer would benefit from mastering.

It is not required that you have worked with C# before but being familiar to the fundamentals in any of the .NET programming languages will help you on the way.

If you are just now starting to learn C#, this can be a great way for you to learn about different techniques, best practices, patterns and how to think in certain scenarios. But if you have worked with C# development for many years, this book can give you a refreshing view on how to always improve and challenge yourself into becoming a better software engineer.

I can’t wait and want to buy it now!

Thanks for the support! Below is a link to Amazon where you can buy the book. It’s available on all Amazon regions.

There’s also an ebook bundle available here.

The post Want a free copy of C# Smorgasbord? appeared first on Filip Ekberg's blog.

The question and code sample is pretty easy, let’s say that we have a class in which we have a static method that returns a new instance of that class. This method takes one parameter which is a dynamic type which means that we can end up with a class looking something like this:

So the question that he asked was, what if we create an instance of it like you see in the following code, what type will the variable be? Because if it is dynamic, we will have lost intellisense.

Without trying this in Visual Studio, what do you think? Leave a comment below telling me what you expected it to be and what it really was once you (continued reading) tried it for yourself!

At a first glance, it looks like the compiler will know that Person.CreateBaby returns a statically typed object of type Person. Before we take a look what happens, let’s inspect the IL with reflector:

That does look like a lot of code for just two lines, right? So most likely it wasn’t as simple as the variable being a static type. By looking over the IL above, you’ll see that a lot of runtime stuff is going on and that we in fact see a lot of dynamic here. Let’s compare the IL to what it will look like, if we make a simple modification to the code by just changing the variable parent to a static type instead:

The IL produced from this is much easier on the eyes:

We still have a dynamic parameter on the method that we are calling so we would have an equal amount of IL as we saw before on that type!

So what did we actually answer here? Simply put what happens when the use of dynamic is in place, the line of code will be evaluated at runtime. If you try casting the statically typed local variable when we pass it to the method, it will be the same behavior as if it was dynamic all along, as you can see in the below screenshot.

Did it work as you expected? Leave a comment and let me know!

The post I’m using dynamic and unexpectedly lost intellisense! appeared first on Filip Ekberg's blog.

As you might know, when you use async and await in .NET 4.5 an internal state machine is created to keep track of the current state. Jon Skeet had a brilliant talk on NDC 2010 where he talked about how goto is truly awesome, in the essence of async & await that is. Without it async & await would be hard to implement accordingly.

This won’t be one of my lengthy posts, this time I’ll leave some of the investigation to you and we might re-visit the topic in the future. Leave a comment about what you think of it all below!

I created a very simple .NET 4.5 console application in Visual Studio 2012 which I named AsyncDemoProject. In this application which you can see below I just created a very simple async operation which I want to inspect further.

The most simple application that I could think of creating was one that simply creates a task that sleeps for a while then returns a string. What my application then does is simply awaiting this and setting a property to a value that indicates that the operation is done.

This ended up looking like the following:

This can be used as simple as this:

What happens when we run this is that a console will be opened and after about two seconds we will see a message telling us “Hello World” of course the console will be filled up with the text “Async is Amazing no?!!!” until that message is shown and that loop is exited due to the condition being met.

If you have a tool installed such as Reflector or IL Spy, open up the compiled executable in that and let’s inspect what happened when we compiled this solution. This did generate some interesting things, normally when you compile an application and open it up in reflector, you will be able to see something pretty much alike what you programmed in the first place. But when adding async and await we have some generated code that needs to be there in order for the state machine to work properly.

Notice that we have a struct generated for us, it even has the attribute CompilerGenerated! This struct keeps track of the state and has methods to help us with that. In reflector we can expand the methods to see the implementations, if we do so, this is what we will see:

Notice the use of label and goto? You might recall the use of label when we jumped around with IL in some of the previous posts on this blog. As you can see the code isn’t really “exactly” as you might imagine from the use of some simple keywords. There’s a lot of magic that happens and above in the code example you can see how the state machine is implemented and how it is used.

Quite interesting right? Let me know what “chocked” you the most about the code generated from asyc and await.

The post What does async & await generate? appeared first on Filip Ekberg's blog.

In a certain dark area of internet, there’s a set of people that see one problem with C# and that’s a problem big enough for them not to touch it with a pitch-fork; Microsoft. Because Microsoft is behind C# a part of the developer community has over and over again claimed it being something that will die soon enough. However, I am sorry to tell you guys that this won’t happen for a long, long time. C# is here to stay.

It’s easy to get very analytic and philosophical about why C# has been successful both in the past, the present and will be in the future. However the reason is quite simple; live free or die hard. C# is a language that lives and does so quite well. In my point of view when a language “lives” it evolves just as anything in life due to the evolution. C# has adapted to the needs of the community over these 13 years or so very well.

When the first release of C# was out, it was a beginning of a new era. Even though we had Java, we wanted something else in the Windows environment. Over the years C# evolved and got generics, lambdas, asynchronicity and soon compilation as a service is hitting the market (+ much more). Even though the last part is not a C# (read: language) feature, it’s something that will be out there due to the languages existence.

C# isn’t the first language that lives on and evolves with the community, so does other great programming languages as well. Even C++ is adapting to this with the new isocpp.org. In the darkest alley-ways we still have the people not wanting to touch C# with a pitch-fork because it’s behind Microsoft, but it’s time to step out of the comfort zone and learn to love it.

No matter if you are a Web, iOS, Android, Linux, Unix, OSX, Windows, Micro-Processor, Tablet, Phone or Refrigerator programmer, you can develop using C# due to Mono and .NET Framework being accessible on all these different platforms.

What is stopping you from learning and using C# today?

As it’s easy to port your C# code to any device and any operating system, you can give great value to your customers systems with reusable code. You no longer have to make one app for iOS, one for Android AND one for Windows Phone. Just use MonoTouch and make one powerful all-device application and be happy with it. For Mobile development, C# is the way to go and Xamarin has posted 8 reasons why, be sure to check that out.

C# was here to stay from the beginning, we love it in the present and we will use it more and more in the future.

The post C# is the past, the present and the future appeared first on Filip Ekberg's blog.

Personally the two biggest achievements of last year was me getting engaged to my lovely Sofie and publishing my book C# Smorgasbord. As you might have seen already this year has already started very good as I have been awarded Microsoft MVP in Visual C#!

Let me know what you found most interesting on this blog from the collection of posts below! Here is the 2012 summary!

Architecture

• Do you use a decent testing strategy?
• Introducing the ASP.NET Web API
• Getting started with a Mocking Framework

Tips & Tricks

• Use LINQPad for more than LINQ
• Running SignalR on Mono
• What’s the difference between doing this and that in C#?
• Avoid shooting yourself in the foot with Tasks and Async
• Things in C# you might have missed

Screencasts

• Introduction to SignalR – Creating a Cross-Platform game
• Dealing with Code Complexity
• Dependency cycles & Spaghetti code
• Demystify Spaghetti Code

Software & Tool information

• Visual Studio 11 Beta
• Roslyn CTP v2 Released
• Roslyn CTP 3 released — breaking changes
• Microsoft Visual Studio 2012 RC Released!
• Visual Studio 2012 is now released to the public<
• NDepend v4 has finally arrived
• ASP.NET MVC, Web API & Web Pages released as open source on CodePlex
• Creating a NuGet Package
• Know your tools

Windows 8, Windows RT, WinRT and Surface

• Creating a Windows Metro style application in C++
• Creating a Windows 8 Store Game with MonoGame (XAML) and SignalR
• How do I choose where I want the new start screen in Windows 8?
• Microsoft delivers at BUILD 2012
• 10 questions about Surface
• Creating a Direct2D game for WinRT

C# Smorgasbord and Self-publishing

• C# Smorgasbord
• C# Smorgasbord will soon be available!
• Video trailer for A C# Smorgasbord
• Self-publishing a book – Part 1 – Where it all began
• Self-publishing a book – Part 2 – Back at Square One
• Self-publishing a book – Part 3 – Using a good typesetting system
• The winner(s) are….
• Win a copy of C# Smorgasbord!
• What is your prefered size on a programming book?
• C# Smorgasbord Sale!

Other

• Questions for a Software Engineer
• Do you deliver high quality?
• Joining new projects
• Being productive
• Let’s write better software
• Organize your thoughts
• Do you care about web security?
• Would you attend my online training?
• Don’t miss me coding on stage for 2 days at Webbdagarna!

I hope you found this collection of posts useful and that you’ve learnt a lot in 2012! Enjoy 2013 and let me know what you think of the posts! Before we take part for this time, I want to share with you an image that describes the feeling I got when I held the first printed copy of C# Smorgasbord:

The post 2012 was an amazing year, here’s a summary! appeared first on Filip Ekberg's blog.

All these contributions has been noticed and 2013 could not have started better, I just received this e-mail from Microsoft:

Congratulations! We are pleased to present you with the 2013 Microsoft® MVP Award! This award is given to exceptional technical community leaders who actively share their high quality, real world expertise with others. We appreciate your outstanding contributions in Visual C# technical communities during the past year.

It is a great honor and I look forward to all the amazing things we will discover together in 2013!

Thank you all for making this possible!

The post Congratulations 2013 Microsoft MVP! appeared first on Filip Ekberg's blog.

Prerequisite; what you’ll need to install first

Before we can dig into the coding part we need to have some tooling installed first. I am going to use Visual Studio 2012 for this. There are however a lot of resources around that tells you how to use MonoGame with MonoDevelop on for instance a Mac.

All you really need to install if you already have Visual Studio 2012 installed is MonoGame. You can grab the latest version (3.0 Beta) over at the MonoGame CodePlex site.

After installing this you should be able to see the MonoGame (XAML) project template in the “New Project” dialog as seen in the image below.

For those of you that don’t have a clue what MonoGame is, here’s a quote from their CodePlex site:

MonoGame is an Open Source implementation of the Microsoft XNA 4 Framework. Our goal is to allow XNA developers on Xbox 360, Windows & Windows Phone to port their games to the iOS, Android, Mac OS X, Linux and Windows 8 Metro. PlayStation Mobile development is currently in progress.

Amazing, isn’t it?

Even more Amazing is that they’re currently working on getting this to work with Windows Phone 8, which this post was initially going to be about but as the support isn’t in the stable release yet, we’ll take a look at that some other time. Tom Spilman tweeted a while back that he got MonoGame working on Windows Phone 8!

There’s actually one more thing that we will need to have installed and this is the XNA Game Studio. This is because we want to be able to add content (Textures and such) to the game. In order to create a Content project we need to create a Dummy XNA project (there might be a much easier way, then please enlighten me!).

Go to File -> New Project -> XNA Game Studio 4.0 and create a new Windows Phone Game. This will create a projected called WindowsPhoneGame1Content inside the solution. Rename this to TicTacToeContent and add the images you’d like to have in the game (You can download all the resources below). After doing so you will need to edit the Dummy XNA project (not the content project and NOT the MonoGame project). This requires you to first unload the project by right clicking the project and then selecting unload. After that right click it again and select to Edit the csproj file.

Add the following right after the Project node:

Then reload and build the solution!

Finally add a folder in the MonoGame project called Content and add the xnb files that was created when you compiled the Dummy XNA project. These are found in bin\Windows Phone\Debug\Content. Select them all and go to the properties tab (Alt+Enter) and change the “Copy to Output Directory” value to “Copy if newer”. Before closing the property window you’ll also need to change the Build Action to Content!

Let’s get some code running!

In order to stay consistent with the code that I previously wrote for the Tic-Tac-Toe demo we can start by renaming Game1.cs to something more suitable such as TicTacToeGame. The first thing we can do is to try and get the Logo in place, I added the following images as Content (xnb):

This means that we will have the following xnb’s and thus be able to load them by their names:

• board (board.png) – This is the game board
• logo (logo.png) – This is the game logotype
• TicTacToeO (TicTacToeO.png) – This is the marker for a Circle
• TicTacToeX (TicTacToeX.png) – This is the marker for a Cross

Adding a texture

The first thing that we can try out to ensure that the content works properly is to load a 2D Texture. Add a private variable that we can access from our Draw method:

Then inside the method LoadContent we can load the texture like this:

In order to actually draw something on the screen we use the sprite batch and we need to tell the sprite batch when to being and when to end. Then we can draw a texture in a rectangle that defines the size and the position like this:

Running this in the simulator will make it look something like this:

Now we’re ready to start with the fun! Let’s install SignalR into the project, we can simply do this by getting it from NuGet!

There’s a known bug in the RC version of SignalR which effects the fallback to long polling. This means that we manually need to define that we are in fact using long polling. After SignalR is installed into the project through NuGet we can connect to the Tic-Tac-Toe server and create a proxy.

First define two private read-only fields in the GamePage class, this is the code behind for the XAML file that was created for us by MonoGame:

You’ll also need to add the reference to the following namespaces:

Now, go down to the constructor of the GamePage class and add this to the bottom of it:

If you recall from previous posts about SignalR we need to hock up the events before we start the connection. This is pretty much equal to what we saw in the WinRT with HTML and JavaScript demo. Here’s what I have to hook it up with the Tic-Tac-Toe server, to make it a bit more fluent we are going to send the request to start a game as soon as the name is registered:

I would recommend to hook these up somewhere else than in the constructor, since the proxy is a member variable. There are two new things in this anonymous function. First we have the function AddMessage that takes a string. Then we have the dispatcher invocation. The method for adding a message is purely for debugging purposes, to understand what I am going with this, take a look at the following XAML for this game page:

This adds a surrounding grid to our view, this view is where we will mix the DirectX graphics and the XAML elements. Worth knowing here is that the XAML elements are always going to be topmost! The surrounding grid will have an empty area to the top left, this is where we will align the logotype that we added before. Then to the right of that we have a list box where we can add some debug messages.

Then finally we have the area where we can register the current player. This is just a simple button and some text fields. The result looks like this when running in the simulator:

As you can see in the top right corner there are some messages added, these are added from the events that we hooked up earlier, but what you didn’t see was when we connected to the server. This is exactly as you are used to when it comes to SignalR, except for the small thing that we are forcing long polling at the time being. This will hopefully be fixed in the next RC.

Other than the method for adding a message we have seen that we have an event handler on the button. This following code sample shows how these two are implemented:

Notice that Dispatcher.RunAsync is showing up again, this is just like the Dispatcher that you might be used to from WPF. We use it to run things on the GUI thread. In this case we want to add something to a GUI element and we can’t do that from another thread than the GUI thread.

I would also not recommend to hook up the events to the buttons like in this demo, but for the purpose of keeping it focused on what is interesting here, you can go ahead and check out MVVM and Commands later on!

The game page which we’ve been working on almost solely so far is pretty much complete, in the below longer code snippet you can see the complete implementation of this class. As you can see much of the code isn’t implemented such as what is going to happen when the game ends, you’re free to add that on your own later. Now we can start looking at the MonoGame and Touch code!

Adding the board, graphics and handling touch

Since this Tic-Tac-Toe game isn’t really that complex, the graphics and game code is going to be quite simple. The game class itself is going to consist of a couple of private fields which we will use a lot throughout the class. These are used to handle the textures that we have loaded, just as we did with the logo before and for handling the game state and the board!

These are the member variables in the game class:

There’s actually one more member to this class which you might have glanced upon in the longer code sample from the game page, which is the action we use to place a marker. This action will just work as a handler for the touch events. So when we touch the screen it tries to send a marker placement to the server. This might of course not be ideal since bandwidth and messages might cost in an enterprise application, but let’s keep it simple.

In case you don’t want to scroll up and see how this is used from the game page, here’s how it’s being used:

Now, there are actually just a couple of methods in the game class that we are using. From the beginning, this class which is called TicTacToeGame is generated and has a set of methods overridden from its base class. Some of these methods are used when content is loading and unloading or when the state is updated. It is also used when we want to draw something on the screen. It’s a good idea to split this up into different “scenes” if your project grows. However, let’s keep it simple!

The easiest method we can start with is the one that doesn’t rely on anything else, resetting the game and the game board. This following method resets the game board by creating an integer array with 9 positions where each integer starts at the value -1.

The code that is commented out is used to test if the board is possible to fill with different markers:

We also have two other methods that don’t rely on anything else and these are for ending the game and for adding marker placements:

The following method is a bit more complex, it’s the method that we use to draw the board. This will use the board placement array to find out where to place the marker in x and y coordinates and then draw it on top of the board. As you can see we use the same methods for drawing the textures as we did with the logotype:

In order to actually draw something on the screen we need to implement the Draw method. This method will actually use the method we just looked at for drawing the board, just so that we don’t have too much code in one method:

One final method that we need to implement before we can run our game is the method for updating the game state. It is also here that we handle the touch events. However, in order for us to interpret the touches at taps we need to enable that type of gesture. This is preferable done in the initialization and looks like this:

The gesture types are enums and are marked as flags, so you can combine different gestures like this:

We can stay with just allowing tap for this demo though. Now let us take a look at how we handle the touches. The touches will be added to a collection and we can keep track of when there’s no longer any touches on the screen. When we have a touch collection we can see if the current touch (the first touch) is within the bounds of our game board.

Then we can calculate where on the game board the touch is and thus finding out the position:

Remote debugging on Surface

I want to try this on my ARM device, so what I first need to do is to change the Platform target to Any CPU as you can see in the image below.

Now verify that you are building against any platform by pressing the arrow next to “Debug” and go to “Configuration Manager”. It should look like this:

Next you need to install and run the application “Remote Debugging” which is available here. You’ll need to scroll down to “Remote tools for Visual Studio 2012″. This should be installed on the Surface (or whatever computer you want to remote debug on!), not the development machine. There’s a great post describing this in details that I suggest you check out.

Finally run the Remote Debugging application on the Surface and set Visual Studio to run on your Surface:

Playing against myself

Now that this is running on the Surface I can bring another instance up in the Simulator and try to play against myself. This is what that will look like:

Recap

This post has gone through a lot of interesting topics and just scratched the surface on many of them. But the idea was to wrap up all the cool things that we’ve looked at with SignalR and Windows 8 for the last couple of months. This post is far to long to fit in a tl;dr but here is a bullet list of the awesome things used in this post:

• Getting started with MonoGame
• Adding basic textures with MonoGame
• Understanding how to add basic images such as PNGs as XNBs with the annoying work-around
• Creating a basic application that uses both XAML and DirectX
• Running MonoGame on Surface
• Communicating with a server using SignalR which runs on Mono, Apache and Linux!
• Wrapping it all together and porting the Tic-Tac-Toe client to a Windows 8 “XNA” Game that runs on Surface!

I probably forgot one or two things in the list above, but you get the point! We looked at some very interesting things and I think that you can take it from here and make some amazing cross platform games and not be limited by what server software you are running (read: this works on linux with Mono and Apache!).

Where can I get the code?

Don’t worry, you can download the entire solution that I worked on here. Remember that a lot of the code is based on the other SignalR posts that I’ve done:

• Introduction to SignalR – Creating a Cross-Platform game
• Running SignalR on Mono

Don’t forget to check out my screencast on SignalR, here it is again so you don’t forget:

I really hope that you enjoyed this post, I had a lot of fun writing it and if you have any questions, leave a comment, ping me on twitter, send me an e-mail or poke me on JabbR.

The post Creating a Windows 8 Store Game with MonoGame (XAML) and SignalR appeared first on Filip Ekberg's blog.

When I later told him that I actually run “real” web stuff on Linux with Mono and Apache, I was asked if I wanted to try get SignalR working on Mono! I love working on Windows so ideally I want to build and test stuff on my Windows development machine and then deploy to one of the Linux servers that uses Mono and Apache. The server that I got this running on is running Apache 2.2.14 and Mono 2.11.

tl;dr: You just need to compile the SignalR dev branch and use those libraries. Upload to a host that already runs Mono and Apache!

Preparing SignalR

The first thing that David instructed me to do was to clone the git repository and grab the latest dev-branch. In the future I expect that this work flow will change a bit, but for now this is how you do it.

Fire up you Git Bash and write the following in order:

1. clone https://github.com/SignalR/SignalR.git
2. cd SignalR
3. git checkout dev
4. git submodule init
5. git submodule update
6. build.cmd

After a while when the project has finished building, you should see something like this:

Since this is the dev branch some things have changed from what you might have seen before. For instance Microsoft.AspNet.SignalR.Hosting.Common.dll isn’t there anymore check inside src\Microsoft.AspNet.SignalR.SystemWeb\bin\Debug for the libraries that you will need to use. The Hosting library gave you the RoutingExtensions which is now moved to SystemWeb

Getting Persistent Connection to work

Now that SignalR is compiled and ready to be tested, we can create a new empty web project for .NET 4.0. Since I tried this on Mono 2.11 I am using .NET 4.0!

Let’s get the most basic thing working; the persistent connection. The idea here is that we want to get the broadcast demo that is available on the SignalR Wiki page working. I also showed this in my latest screencast about SignalR.

First we need to add the references to the SignalR libraries that we just compiled and set them to be copied locally.

As you can see the references are from src\Microsoft.AspNet.SignalR.SystemWeb\bin\Debug.

Before we start coding, we can add the JavaScript which you can find in src\Microsoft.AspNet.SignalR.Client.JS\bin. Now we can do just as the Wiki page instructs us to do.

Add a class called MyConnection with the following content:

You will also need to add a Global.asax file with a route added:

Finally we can add a HTML file with the following content:

Now we’re ready to compile and run it!

Running it on Apache with Mono

I’m not going to cover how to set up Apache with Mono, there are plenty of tutorials for that out there already. However, all I did was create a new virtual host that is Mono enabled and I copied the content over to that folder and it just works!

Converting a SignalR application to run on Mono and Apache

As you might have seen in my screencast on SignalR I’ve created a Tic-Tac-Toe game, which is also available on github. I downloaded the master and opened up the solution to make the changes needed to get it running on Mono and Apache.

First thing that needs to be done here is to change the Target framework to .NET Framework 4 instead of 4.5. This will cause some issues with the SignalR version that was grabbed from NuGet. So you will also need to remove those before proceeding.

Just as we did with the persistent connection, we need to add the libraries that we compiled and also add the new javascript:

Now we need to replace the SignalR script that we are using in the client HTML to the new script file that we just added to the solution. In the case of Tic-Tac-Toe we replace:

with

Finally if you haven’t already, force long polling for the time being:

Compile and run it locally to test that it still works then upload to your favorite Mono hosting! There’s a live demo available at signal.fekberg.com that looks like this (and as you can see it runs on Mono + Apache!):

Need an introduction to SignalR?

The post Running SignalR on Mono appeared first on Filip Ekberg's blog.

I recorded this presentation, but since it’s in Swedish I will not bother embedding it into this post; it’s available on my YouTube channel for anyone that wants to have a look at it!

The questions for a Software Engineer

The students had put together a list of questions, 19 questions to be precise and most of the questions were aimed at me and my career. But I think that many of these questions are among the commonly asked ones, I’d like to share the questions and the answers with you all. So here goes, have an awesome Friday and enjoy the Q&A! If you have additional questions for me or any comments on the answers that I gave, please leave a comment!

When you started upper high school, how good were you at programming?

I was somewhere between 10 and 12 years old when I first saw programming in action. Back then we didn’t have fancy computers, of course they were fancy at the time but not as todays computers. I remember my best friend back then showed me QBasic and how to do basic input, conditions and output. So I just wrote some basic programs in QBasic that asked me a question over and over again until I gave it a certain answer.

This was fun and all, but it kind of stopped there. I didn’t have my own computer until I was 12 years old and at this time my friend had learned VB which I gave a try but never really got into it. I was young and my focus at that time wasn’t to become a programmer. I liked computers and I liked exploring them but the games on my computer was calling out to me.

As I was born 1987, being 12 years old puts us in 1999. We had no high speed internet at this time and some of the operators in Sweden actually charged per megabyte that you downloaded. So googling for video tutorials wasn’t really an option.

So let’s speed it up a bit, when I was 16 years old I started upper high school. I had chosen to become an electrician just as my father. But after 1-2 weeks I felt that something was missing, so I actually changed schools, mainly because the programming kids got their own laptops at the school. Up until now I had actually played a lot with computers so I wasn’t a completely newbie on that area. But my programming skills wasn’t that good and fortunately for me, they didn’t expect that in high school either.

This means that the short answer is, I wasn’t any good at programming at all when I started high school. I had tried some when I was younger, but that wasn’t enough. Eventually we started looking at HTML and this being static and all, I wanted some dynamic behavior in my web pages so I bought books and learned PHP. In the final years of high school we were doing C# and I were de-compiling the teacher’s examples and changing stuff and then re-compiling them.

Programming had by then became a part of what identified me and who I wanted to be.

What was the hardest part about writing/releasing your own book?

There were a lot of bumps in the road when writing the book. I’ve written about the writing process and what decisions that I made along the way.

But if I need to choose one of the most hard parts about writing the book. That would probably be: handling all the input from proof readers.

The hardest part about releasing the book has been all the rules and tax stuff. Since I use CreateSpace which is a USA based company there are a lot of different rules regarding taxes that are very hard to get your mind around. I’ve spent countless of hours trying to figure all that out.

How did you experience studying in Blekinge (the county where I studied for my BCs in Software Engineering)?

This county is in the southern of Sweden and the town that I studied in is called Ronneby. It’s hard to compare this to any other cities that you might have heard about. This town (if you can even call it that) is so small that when you go out to buy something, you know Everyone and everyone knows you.

Ronneby changed my life, if I would have never met my wonderful girlfriend if I hadn’t moved to Ronneby.

The school itself is awesome, we had the highest number of researchers in the field of Software Engineering in Sweden.

Have you earned any money off the book, if so how much?

It depends on how you look at it. If you take all the time that I’ve put down on writing the content and then multiply that with whatever my time is worth. It would be so much that this book would have to sell as good as Harry Potter before I can say that I earned money from it.

The royalties are much better when self-publishing, but a lot of that money needs to go on additional marketing if you want to sell more books.

I didn’t write the book for money, I wrote it because I love what I do and I want to share this with everyone.

Why did you write a book?

There are so many different things that inspired me to write the book. A lot of the great authors that I met at NDC in 2011 and a lot of people that I’ve met in my career prior to that.

But the definitive moment that changed everything was when I applied for a job that I didn’t get. For some reason there wasn’t enough “evidence” that I was a good enough programmer for that position. This inspired me to write a lot more in my blog. I’ve focused my energy on other things before and I’ve always enjoyed talking and writing about programming and technology.

So I started writing my blog because I was inspired, sort of by myself, because I wanted to do more for the community and I wanted to share my experience and knowledge.

As I wrote before, there were a lot of reasons to why I started writing this book. Mostly inspiring has been all the people around me and the developers that I look up to.

How are the sales of the book going?

It’s going great! I’ve been selling around 70-100 books per month since it was released and all feedback that I’ve gotten has been very positive!

How do you sell the book and how do you market it?

I sell the book through CreateSpace. CreateSpace is a print-on-demand company that sells the book through different channels such as Amazon. It’s also available on Kindle and as an ebook bundle!

My girlfriend has bachelor degree in marketing, so I try to get as much help from her as possible on this. Lots of the marketing that I’ve done so far is the discounts that I’ve handed out and the books that I’ve raffled away.

Most importantly: Word of mouth.

Who read the manuscript during the writing process?

At one point I had 8 people that wanted to dedicate their time to read and proof the book. This was all during the writing process and after I had finished writing.

I’ve thanked all these amazing people in the Acknowledgement section in my book, be sure to check that out when you buy my book!

Do you have your own business, if so what type of business is it?

Yes, I’ve got a sole proprietorship.

When you started your own business, did you make an initial budget?

No. I should have made one though. A couple of years after I started my sole proprietorship I found out that it would have been better to actually know what money comes in and comes out in the long run. Everything worked out for the best though!

I really recommend you to do a budget and a business plan if you’re thinking about starting up something.

What kind of system do you use to keep track of all invoices and papers in your company?

I wrote my own system to create invoices. I was 18 years old when I started my sole proprietorship and I didn’t really want to buy a system for this since I could write one myself.

What is the best way to learn programming?

This is way too subjective to give one answer to. I learn best by being inspired by someone. It can be watching a video on Channel9 or maybe attending a conference where there’s all these amazing people talking about new and fun technology and how to use it.

If you like reading buy books. If you like listening watch screencasts. Nowadays there are ways for everyone!

What is the hardest part about programming?

Understanding the system requirements. The customer or whoever you talk about the system you are going to build with have one way of expressing what they want, when they really want something else. One of the biggest problems that is actually fundamental in domain driven design is that you need to speak the same language!

Why C#?

Why not?

Seriously though, C# is a living language as I call it. There’s a lot of changes happening to the language and how you work with it. If you look back at .NET 1.1 and compare the C# code from then to code from today, both of them are understandable and similar. But there are so much more help in the newer versions of C# that helps you write even cleaner, faster and easier to understand code.

Another important thing, at least for me is that I’ve always loved Microsoft. I’ve got a hard time staying away and not preaching their stuff.

What other programming languages do you know?

I started off with PHP when I was 16 and then I learned Java. From there I’ve learned to love some of the following: C#, C++, ASM (MIPS+X86), Python.

Probably forgot one or two languages but those are the ones that I would be comfortable doing projects in. I would probably have to do some reading up if someone threw a MIPS project in my face.

Do you have a role model?

There’s too many people that I look up to. My parents and my family has always been what drives me to do greater things.

In the profession there’s also a lot of great people that I look up to such as Bill Gates, Steve Ballmer, Eric Lippert, Steve Jobs, Scott Hanselman, Scott Guthrie, Jon Skeet and many more.

To be honest, I look up to everyone that loves what they do and do everything to share that passion.

How long did it take to write your own book?

If I include the time it took to prepare all the raw content, I think it lands somewhere around 2000 hours.

Do you also work as a Software Engineer or are you just an author?

I work as a full time Software Engineer at Star Republic in Gothenburg meanwhile as I have my own sole proprietorship and doing all the work with the book.

I’m a man with many hats and I like to have many projects in the pipe!

Will there be a sequel to the book?

Depends on who you ask. If you ask my girlfriend the answer is no.

All joking aside, she supports me in writing another one but currently I am focusing on C# Smorgasbord and everything that is needed to be done after a release of a book.

I’ve got plans for more books, but time will have to tell what happens.

End of Q&A

I really hope you enjoyed reading these Q&A’s, I sure did writing them!

The post Questions for a Software Engineer appeared first on Filip Ekberg's blog.

The post Introduction to SignalR – Creating a Cross-Platform game appeared first on Filip Ekberg's blog.

Windows 8 doesn’t lack a “Start button” but they’ve replaced the old one. Install a tool like Start8 is like painting a new red Ferrari F50 as a rainbow; simply not by design.

Windows 8 has different use-cases

When I attended //BUILD/ Microsoft gave me a very nice Surface that I really like and what I like the most is that the transition between a tablet and a desktop computer is an awesome experience. I use the two devices completely different but still feel like home when using both of them. I rarely go into the standard desktop mode on my Surface, I only do so when I need to do some Word-processing or just manage files and on my Workstation I rarely go into the new Start screen (Modern UI), I only do so when I want to use the very powerful search.

There’s a Start button on Surface and it’s required by all vendors as far as I know that it’s there. This hardware button is one of the replacements for the old start button!

I don’t really use that so much because I find it much easier to just swipe from the right and get another start button. You can also press Win + C to get to this menu and you can also bring the pointer to the right corners to get this menu showing up!

So far there has been four ways to get a start button showing up which brings you to the new powerful start menu. The hardware button can easily translate into the keyboard start button and the swipe from the right is the point in corners version.

However, that is not it! There’s actually another way to show a start button, which also dictates where the start menu will show up.

How do I know where the start screen shows up?

I’ve heard people saying that they think the behavior of where the start screen is showing up is random, but frankly it is not. If you have a Modern UI application running on Screen 2, this is where the start screen will show up. If you move the application to Screen 1, that is where the start screen will show up.

But if you don’t have a Modern UI application running, what then?

Use the start button in the corners!

This start button shows up when you hover the different left bottom corners on any of your monitors and it will bring up the start screen on that monitor.

So you were saying there’s no start button? The old start button is gone, the old start menu is gone. It has been replaced by something much more productive and intuitive, step out of your comfort zone and just adapt to it!

It’s all about HCI (Human-Computer-Interaction) and making the experience better for everyone, but it takes time change an old behavior. Why do you so eagerly want the old start button/menu back?

In case you’ve missed it C# Smorgasbord is currently on sale and I’m giving away discount codes for 35% off!

The post How do I choose where I want the new start screen in Windows 8? appeared first on Filip Ekberg's blog.

Discount code: N9UV3WDP

Note that the Discount Code only works on CreateSpace!

The printed copy includes access to the ebook bundle; so you don’t need to wait for the printed copy to arrive. After you’ve purchased the book just fill out the form on the book’s website! CreateSpace ships globally and their shipment times are in most cases a lot shorter than what it says in their website.

Want to know more about C# Smorgasbord?

Want to peek inside? Sample available!

There’s a “Look Inside” available on Amazon!

About the book

Looking at everything from testing strategies to compilation as a service and how to do really advanced things in runtime; you get a great sense of what you as a developer can do. By taking his personal views and his personal experience, Filip digs into each subject with a personal touch and by having real world problems at hand, we can look at how these problems could be tackled.

No matter if you are an experienced .NET developer, or a beginner, you will most certainly find a lot of interesting things in this book. The book covers important patterns and technologies that any developer would benefit from mastering.

Table of Contents

• Introduction to Parallel Extensions
• Productivity and Quality with Unit Testing
• Is upgrading your code a productive step?
• Creating a challenge out of the trivial tasks
• Asynchronous programming with async and await
• Dynamic programming
• Increase readability with anonymous types and methods
• Exploring Reflection
• Creating things at runtime
• Introducing Roslyn
• Adapting to Inversion of Control
• Are you Mocking me?

Want only digital versions?

If you don’t want to get the printed version you can get the ebook bundle on the book website or the Kindle version on Amazon.

Enjoy the read and spread the word!

Update 2012-12-02

I am extending the offer the rest of 2012! Enjoy the holidays!

The post C# Smorgasbord Sale! appeared first on Filip Ekberg's blog.

Welcome to this week’s Friday with Filip!

There’s a saying that goes like this:

Use the right tool for the right job

Even if you find the right tool for your job, do you know how to use the tool correctly?

This is exactly what I want to talk about this Friday; you need to know your tools in order for you to know it’s the right tool for this job!

Do you know your tooling?

All too often I see developers using amazing new tools but in many cases not knowing the limits or how to use it correctly. It’s very important to understand how to use a tool and what the implications of using a tool in a certain way has. When I find a new tool or a new library that I want to use, I try to research it and understand it before I recommend it for production use.

To me a tool is not only a software that I run or a hammer that I use, but I also consider a third party library a tool. A tool for me is something that I use to solve a certain problem and smaller parts can build a larger tool.

Problems with not knowing your tools

If you don’t know what your tool does behind the scenes you can get very big problems in the end. If you try to use a hammer to screw something into the wall there might be an easy work around just to hammer the screw into the wall. But what if it was the other way around?

Imagine that you had a screwdriver but a nail that you had to put into a plank; getting that into the plank would be much harder, no?

It’s still possible of course to solve the problem by just using the other end of the screwdriver and hammer the nail slowly into the plank.

So where am I going with this?

If you use a library or software that is new and hype which solves a certain problem but makes it harder for you; maybe you’re doing it wrong! The tooling might be great for solving one of the problems, but the way that you use it just gives you too much of a headache. If you go back and do some research on the tools, you might find that you are using it wrong or that the tool simply is not for the specific use case.

A good example here is LINQ to EF. I’ve seen many developers knowing how to use LINQ but not knowing what happens behind the scenes. This can be very dangerous for the performance of your application.

One other problem that arises with this is that most of us test our applications with very little data in it, but in a real world application after some time there might be a lot more data to process which was not considered at the beginning.

Now to be a bit more concrete, see of the following LINQ to EF query:

This can of course be written like this as well:

Both of these will be executed as soon as you request the result by doing persons.ToList(); for instance.

This all looks very good, it might be exactly what we want to do as well. But what happens if we have 1 billion persons in our database?

The SQL query that is generated from this will perform what is called a row search, which means it does not use any indexing which means it will have to go over 1 billion persons and do a search within each person’s name.

Consider that it generated the following SQL:

Of course we can optimize this by using full text search! But that is not the point, the point is that we might not have considered that Contains() will actually be a slow operation to run. If we knew that this would skip all indexes we might had chosen to use StartsWith() instead.

Another problem with not knowing how LINQ works internally is that all too often I see developers doing ToList() just because they want to use the types in .NET instead of having it translated to SQL. If they had known of EntityFunctions or SqlFunctions they might had chosen to run the query on the database side instead of doing LINQ to Object!

Because if we perform the query below, we will actually fetch the 1 billion rows from the database and have them in memory and then perform the search in the application instead.

Again, if we know our tooling and use the right tool for the right job, we are going to do a much better job.

Do you know your tools?

The post Friday with Filip – Know your tools appeared first on Filip Ekberg's blog.

Welcome to this week’s Friday with Filip!

Last week I shared the first part in a very interesting session that I had the pleasure to do with Patrick over at NDepend. Having readable code and manageable solutions is very important but in some cases small changes that might see, trivial to you, might not be as trivial to someone else.

If you had to keep track of all dependencies in your head you are not going to have anything else on your mind; which is a pretty bad way to distribute your brain! Instead of keeping it all in your head, you can use a tool like NDepend to find out a lot of interesting things about your projects. If you’ve seen the previous posts and videos that I have done on NDepend, you know what kind of power this tool delivers.

The webinars that I have had the pleasure to do with Patrick has been very educating and I hope you like them as well, I would love to get some feedback!

So this week we are going to dig deeper with NDepend and spot dependencies, dependency cycles and spaghetti code! As we look on mscorlib, you can see that in some cases bi-directional dependencies are by design, but in other cases it might have been accidental. Sit back and enjoy the two parts below!

Part 2

Keeping our code base clean and understandable is important and as you might have seen now, there are tools that can help us along the way.

What are your tips on the subject?

The post Friday with Filip – Dependency cycles & Spaghetti code appeared first on Filip Ekberg's blog.

Me and my colleague from Star Republic arrived in Seattle a couple of days before the conference started to avoid being jetlagged during the session and be able to see a bit of Seattle. Despite all the rain in Seattle we have had a very nice visit so far. We’ve been able to see the Space Needle, the underground (which is awesome by the way), the harbor and much more. I really enjoy Seattle, maybe it is because it feels pretty much like Gothenburg. What’s best about it though is that it is flooded (not with water despite the rain) with geeks.

The days before the conference I had a chance to meet up with Scott Hanselman and a lot of the other amazing guys working on the ASP.NET team. If you haven’t seen the Day 2 Keynote the next part of this sentence is going to be a spoiler; I’m somewhat in the keynote! When I met Scott he needed material for his presentation, me and some other guys’ danced Gangnam style for him which was recorded and put in his and Scott Guthrie’s presentation. I don’t have the video available at the moment, it’s going to be available on C9 as soon as the keynote is uploaded. I recorded a little with my compact camera, but I forgot to bring a cable for it and unfortunately the Surface RT don’t accept an SD card!

All that was day two, besides for the actual recording, so up until now everything has been awesome. The sessions were all similar to the ones that we have seen over the year since last //BUILD/ but now that everything is shipped it’s more hands-on examples. I attended a couple of sessions about Windows 8 development with HTML and Javascript (and of course CSS). The most interesting session was the one about optimizing your web application by thinking about CPU usage. There are some very interesting tools in the Windows SDK that you can use to analyze the performance of a web application. Basically in most applications on the web, time is spent on waiting for resources to be downloaded which means it could be done asynchronously if possible and the other thing that is common is slow javascript with lots of DOM access.

As an attendee the highlight of the day was when Ballmer announced that everyone is getting 100GB of SkyDrive! I am actually going to swap from DropBox for a while to see if it is better or not. However that awesome present wasn’t enough for Ballmer so he also announced that everyone attending would get a Surface RT 32GB! When everyone calmed down and promised to write awesome apps for Windows RT, the VP for Nokia comes out on stage and gives away a Lumina 920 to everyone attending the confidence. At this time I wanted to lay down on the floor and cry of happiness. This was announced in the morning so we had to wait for our awesome devices for the entire day!

As soon as we picked up our stuff we went back to the hotel and I recorded an unboxing (I know most people hate those!) and hands-on.

Are you planning on getting a Surface?

I’m having high hopes for the ASP.NET session and hoping to see some things that will help me in my daily work. So far the Azure upgrades with Mobile Services and Add-Ons are Very promising and I am really looking forward to playing with it more. What is funny is that Halo 4 that is being release in the next months or so uses Azure a lot which forced them to rethink the server architecture.

Speaking of games, since everyone got a voucher for the company store which has heavy discount, I might grab an xbox controller to use for my next Windows 8 game. Do you have any experience with that? I would love to hear about it!
If you’re at //BUILD/ be sure to look me up and say hello and if not, just ping me!

Before we take part, I just want to say that I wrote this entire post on my Surace with the TouchCover. Takes some time getting used to.

The post Microsoft delivers at BUILD 2012 appeared first on Filip Ekberg's blog.

Welcome to this week’s Friday with Filip!

Two weeks ago we looked at Dealing with Code Complexity using NDepend. This was the first episode in the webinar series on Code Quality.

This week I am happy to share that Patrick Smacchia and I have recorded the second episode! This week it’s about dependencies, dependency cycles and spaghetti code. I really enjoyed doing these sessions with Patrick and I really hope you will enjoy it just as much. Let me know what you think of it!

The post Friday with Filip – Demystify Spaghetti Code appeared first on Filip Ekberg's blog.

Welcome to this week’s Friday with Filip!

During the Fridays with Filip we’ve looked at how to ensure that certain parts of your project conforms to a high standard. I’m talking about the following:

• Ensuring that we have a decent testing strategy
• Talking about security in your project
• How to be productive and deliver good quality in a tight time schedule
• If you need to get a crash course in a new project, you’ll want to deliver things with high quality as soon as possible
• How to spot complexity in your code base and possibly how to solve it

There are so much more things (even small things) that matter when you want a successful high quality project/solution. You can’t rely on a decent testing strategy, security awareness and rapid development to get high quality. There’s still a lot of other aspects in your project that you need to take into consideration.

When I studied for my Software Engineering degree there was a lot of talk about requirements documentation, design documents and all other kinds of documents that you had to write in order to get a good overview of the project. But there were actually less talk about how to retrieve this information.

One of the first things you’ll learn when talking about domain driven design is: use a language that both you and your customer understands. In order to get all requirements or the system design onto paper, you need to understand each other. Do you see where I’m getting at? We need to step back to the basics, to things that was important even before computers and software projects; we need to be able to talk to each other so that everyone understands!

Previously this week I asked something a bit weird on twitter as you can see in the image below.

At a glance, this might be a very weird question. Why would you explain something that is so far away from their reality? Someone responded and said that they would just not do it because they would probably be killed for knowing too much.

Technology is amazing and as a Software Engineer with a burning heart for programming I tend to try (almost) everything new that arrives to the market but not everyone do and this is very important not to forget. Since not everyone is so used to technology, we need to work on the way that we communicate with each other. A couple of years back I built a website that had to do with cars and the people that wanted the website had no idea how the process of building a website looked. So I had to use analogies they understood, I had to talk in car terms.

Therefore it’s very important to actually step back and find a common ground between you and your customer. Otherwise it will be near to impossible to deliver high quality; you’ll never get the right requirements!

As I said in the start of this there’s not one or even 5 things that will ensure you deliver high quality, you need to work on all different aspects. Here are some concrete suggestions (that might seem obvious):

• Find a common ground between you and your customer so that you speak the same language
• Design the architecture in a way that you could talk about objects and structure in the application which the customer understands
• Use the right person for the right job!
• Write lots of documentation before, during and after the delivery
• Have small iterations in the beginning where you continuously deliver parts of the system for reviewing
• Do code reviews, swap people around and let everyone review everyone
• Don’t be afraid to ask your customer questions if you don’t understand
• Don’t be afraid to ask you colleges for help if you’re stuck!
• Don’t get used to putting work off by writing TODO’s in the code
• Take a couple of seconds to write a comment about a method or a complex code block
• Remember that we’re all human, everyone can make mistakes; help each other out and solve them together
• Stay on top of new/old technology and use what is best for the project/customer. If a newer framework or tool means more job, maybe it’s the wrong tooling for this job; even if you want to play with the latest toys

This list can go on and on, frankly there have been books heavier than my laptop written about each point in the list.

What’s your pro tip to increase quality in the code, project and customer communication?

The post Friday with Filip – Do you deliver high quality? appeared first on Filip Ekberg's blog.

Some background

If you’ve somehow missed what the Surface is or what the Surface looks like, below is a very nice picture of it. Basically it’s a powerful and lightweight tablet that runs Windows 8.

Up until today, at least I have always felt that I at least needed 3 devices. One touch optimized tablet (iPad), One laptop to bring in to meetings that I can also code on and last but not least a very powerful workstation that I can work on. With the Microsoft Surface, we’re closing up with the all-in-one device — simply bring the Surface with you to meetings, watch movies with it in the couch or work on it.

How come information about such hardware ends up on a programming blog? Because the programming model is very interesting! If you’re an iOS developer or an Android developer, you’re most likely familiar with the whole “store” life-cycle; which is great. This will (hopefully) lead to much more high quality applications and less bogus software.

Surface comes in two (majorly) different models

The first Surface that is released October 26 will run Windows RT on an ARM architecture. The RT version of Windows 8 is designed for limited use such as:

• Watching movies, surfing the web, chatting and all that other tabletty stuff
• Minor work in Office; Word, Excel, Powerpoint, etc.
• Only run applications from Windows Store

There’s of course a little more to it, but the last point is the most interesting one. You’ll only be able to run applications on the device that comes from Windows Store! Hence that you will not be able to put an application on an USB drive (yes Surface has a fully functional USB 2 port) and run it.

This might not be new information to you, but it’s still pretty interesting. That’s why there’s another Surface version released in January, called Surface Pro. This version runs on an Intel Core i5 and used the full version of Windows 8. This lets you install any applications that you want and use it as any other computer that you are used to. Plus it’s still a tablet!

Below is an overview of the Windows RT Architecture; The RT API is a little bit different (limited).

Now with a little bit of background, let’s take a look at 10 questions and answers about the Surface!

All the following information is based on information given by the SurfaceTeam on reddit.

1. Why doesn’t surface come with 3G/4G

For 3G/4G we looked at several elements when deciding on what features to include. We knew that the primary use was going to be in the home, we looked at tablet sales data 2/3 WiFi, 1/3 Mobile Broadband. Of the 1/3 sold, 1/2 were activated. Phone hotspot / tethering use was also a consideration.

2. Will Surface be available in any other countries than listed at the moment on the release date?

Unfortunately, no.

Of the primary launch Markets we are launching in, we have keyboards specific to those languages
We are not announcing any new markets beyond what we said today. However, we will for sure be expanding to more markets in the future.

3. Why is there no USB3 port, only USB2?

Currently there’s no ARM SoCs that have an USB 3 controller and Surface is based on ARM, which means no USB 3.

USB 2.0 based on capability of the ARM SoCs during our development timeframe.

4. How much will it cost?

There are a couple of different options available (USD prices only).

• Surface with 64GB Storage and TouchCover – 699 USD
• Surface with 32GB Storage and TouchCover – 599 USD
• Surface with 32GB Storage without TouchCover – 499 USD

5. Is there any NFC or GPS on Surface?

There isn’t a NFC feature in Surface RT; We use Wi-Fi based location services, the device doesn’t have a physical GPS sensor.

6. Why is the kickstand angled as it is?

We wanted the screen to be normal to the face. Voila, you then have a 22 degree angle.
Seriously we did a ton of studies around lighting, reflection, ergonomics, table height, etc…. and then made sure it looked perfect and felt perfectly balanced.

7. Will Surface support bluetooth headsets?

Yes, Surface supports Bluetooth 4.0 and will work with Bluetooth headsets.

8. What happens when I flip the touch cover to the back of the device, will there be accidental keystrokes?

Both TouchCover and TypeCover have sensors that understand orientation relative to Surface… in fact the Type and Touch Covers talk to Surface to figure out their relative position no matter the orientation of gravity of the device (pretty neat!). There are 3 positions modes: Closed (keys and mouse are off), Open to 180 degrees (keyboard and mousepad on), beyond 180 degrees to the back (keys and mouse off). That way you can flip back the covers and feel secure you are not pressing keys by mistake.

9. How does the TouchCover work?

Touch Cover has a very special digitizer that we invented.. it senses the impact force of your key presses. We designed super-fast electronics and smart algorithm in the keyboard so that Touch Cover can profile your key press down to a 1ms (1000 times a second). Using that information Touch Cover can infer if the user meant to press the key or not.. It is a smart key. So even though there is no key travel, the user can rest their hands on top of the keyboard and find home position without accidentally triggering keys.. pretty cool! The first time I typed on a full working version of Touch Cover, I typed just as fast as I do on a normal keyboard. I am confident you will be able to type significantly faster on Touch Cover than an onscreen keyboard. And with a little practice you will even do better (maybe even faster!) For folks who really love and really need keys that have travel, then Type Cover is one of the best keyboards I have ever used (desktop or other). It has a super awesome snappy key mechanism that feels great (has a strong hysteresis curve)

10. So there’s no NFC, why?

For the product design experience we were aiming for with Surface, the Mg metal enclosure, including the back case, was critical. This made good antenna design for NFC a trade-off in our development process.

To learn more about Surface, check out the video below!

Personally I can say that I am very excited about the Surface products, both RT and Pro.

How excited are you?

The post 10 questions about Surface appeared first on Filip Ekberg's blog.