Continue reading »

The premise of coding to interfaces has been around for awhile now. The concept is simple. Given a definition of something you create things based on that definition. That might be a horrible description of an interface but I didn’t want to go all Computer Science on you.

Interface? What’s an Interface?

Here’s a simple interface:

   1: interface ICustomerService

   2: {

   3:     IEnumerable<Customer> GetAllCustomers();

   4: }

Pretty basic. We have a Customer class somewhere and this interface describes a method called GetAllCustomers that will return you a list of Customer objects.

With an interface you don’t have an implementation. There’s no code here to say where we get the customers from, just that we expect this to return us a list of them.

Now in our code we can write something like this:

   1: public void DisplayAllCustomers(ICustomerService service)

   2: {

   3:     foreach (var customer in service.GetAllCustomers())

   4:     {

   5:         // Output whatever customer info here

   6:     }

   7: }

The method here expects an object that implements the ICustomerService interface. That’s how we can build and compile this but we have yet to build an implementation of this method. Of course the code won’t run because your application doesn’t know how to create an object that implements ICustomerService.

Like I said, the implementation is up to you but you’ll probably be driving it from requirements or what the user needs to see or whatever. Here’s a sample implementation:

   1: internal class CustomerRepository : ICustomerService

   2: {

   3:     public IEnumerable<Customer> GetAllCustomers()

   4:     {

   5:         return new List<Customer>

   6:                     {

   7:                         new Customer {Name = "Harold"}, 

   8:                         new Customer {Name = "Kumar"}

   9:                     };

  10:     }

  11: }

So if we created an object of this CustomerRepository class and passed it to the DisplayAllCustomers method above, we would output Harold and Kumar’s names (or whatever your display code was).

The $10,000 Question

People will stare at the code and say, why? Why create that ICustomerService and then have to go to the trouble of creating it and passing it along to the DisplayAllCustomers. More code to maintain they say. More work.

Let’s try to dispel some myths here.

Coding to Interfaces is Hard

Really? Do you understand the code above? That’s coding to an interface. Could you do that yourself? Sure you can. Let’s move on.

Coding to Interfaces Constrains Me

It’s true. If you added the method “void AddCustomer(Customer customer)” to your inteface, you wouldn’t be able to compile your code. The CustomerRepostory class (and any other class that implemented the ICustomerService interface) would require it. Stop thinking about this as a constraint, it’s a design choice. It’s like the Architect giving you a window or door on the side of your house. You don’t go cutting open another hole because you want another window. You have to take into account load bearing walls, structural integrity, etc. which is what the Architect does (I know, I used to be one). Just because it looks good or you need it, doesn’t mean it should be done (at least in the way you might want it).

Coding to Interfaces makes you do extra work

Yes, you have to create those interfaces so yeah, that’s extra work. Some might argue that if your implementation is simple then you’re writing double the code. Again, all true. There are benefits that will outweigh this which we’ll look at in a moment.

Where are the Benefits?

Let’s talk some benefits here. First coding to an interface is giving you a layer of abstraction. Remember that ICustomerService above? The implementation is sort of silly but shows that we can write code that does what the system intends. We could also build an implementation that reads from a database. Or Active Directory. Or SAP. Or a Web Service. Each time we write a new implementation, we don’t have to change our DIsplayAllCustomers method.

That’s abstraction. You don’t have to worry in your DisplayAllCustomers method where the data came from or what infrastructure may or may not exist. All you care about is that you expect a list of customers to come back.

Now multiply that by 10 or 100 and you get the benefits of abstraction against a real codebase.

Some people will talk about future proofing and interfaces and while that may be a benefit down the road, and it can happen, consider it icing on the cake. Imagine if you had coded to an IEnumerable interface instead of ArrayList? Now you *might* not have to rewrite a lot of code (or any if you’re really lucky).

I do believe, and have rarely seen, entire implementations changed. For example one classic is the “build a database interface so we can swap between SQL and Oracle”. You build an abstraction over a database to make it simpler to code to but not necessarily swap out technologies.

Just don’t use the future proofing claim as a crutch to not code to interfaces claiming YAGNI or something. There are different reasons for this.

The other big thing is testing. Going back to our CustomerRepository. It’s an in-memory representation to a list of customers. Imagine you had additional methods on your interface like this:

   1: internal interface ICustomerService

   2: {

   3:     IEnumerable<Customer> GetAllCustomers();

   4:     void AddCustomer(Customer newCustomer);

   5:     void DeleteCustomer(Customer customerToDelete);

   6: }

And now with your in-memory representation you can write tests that ensure items are added and deleted in your repository and the counts all match and the list comes back with the right names. Now you’re starting to test against your interface, which is a good thing.

Testing

Testing frameworks will let  you do things like create stubs or fake implementations of the interface, without actually writing code to return actual values. Without interfaces if you tried to test the AddCustomer method in say a SQL based implementation, you would need a database, login information, test data, etc. That’s great for infrastructure tests but for unit tests it’s a lot of overhead you shouldn’t be getting into.

Another benefit is getting ahead of infrastructure. Imagine if your ICustomerService is going to talk to a web service, as web service that won’t be written for another month. You could go ahead and wait for the infrastructure to show up, code concrete classes against it, and then start your testing but now you’re in the crunch to get the system done and you’re just starting your unit testing.

Instead, based on requirements and perhaps UI discussions with users using paper, whiteboard, or digital wireframes, you come up with the interface. “We’re going to need to display the customer fields and oh yeah, we want to search by first and last name”. Great. From that description you can come up with an interface something like this:

   1: interface ICustomerService

   2: {

   3:     IEnumerable<Customer> FindBy(string firstName);

   4:     IEnumerable<Customer> FindBy(string firstName, string lastName);

   5: }

Again we can write up some implementation (maybe going against a preset list of names you import from a spreadsheet) and actually build out a working UI. The user can put their hands on it, search by names, and see the results returned. All without that pesky infrastructure. Then come the say the database gets built, you create your implementation to read it and do searches and BAM, your system is online and working end-to-end.

On the testing front again, how would you test something that’s dependent on DateTime? For example you have a piece of code that ages some items in a system based on some business rules (or expires them).

It’s all well and fine to start tossing around DateTime objects like this:

   1: public void ExpireTest(ICustomerService service, DateTime date)

   2: {

   3:     foreach (var customer in service.GetAllCustomers())

   4:     {

   5:         if(customer.ContractDate > date)

   6:         {

   7:             ExpireContractFor(customer);

   8:         }

   9:     }

  10: }

However things get real ugly real fast. First I have to write this test and I’m sort of breaking both encapsulation and responsibility of the customer class. Maybe I should have a method on customer that takes in a DateTime object. Yuck. Now I’m passing that value into my business object which might be okay (it depends) but now consider the idea of something like this business rule:

   1: foreach (var customer in service.GetAllCustomers())

   2: {

   3:     if(customer.ContractDate.Day == date.Day && date.Hour > 12)

   4:     {

   5:         ExpireContractFor(customer);

   6:     }

   7: }

Now I’ll only expire the contract if the date passed in is the same day as my contract and it’s after noon. Silly logic yes, but would require another test method, another date object to be passed in, etc. A lot of setup to test something and then along comes this somewhere in my Customer class:

   1: class Customer

   2: {

   3:     public string Name { get; set; }

   4:  

   5:     public DateTime ContractDate { get; set; }

   6:  

   7:     public int AgeOfContract()

   8:     {

   9:         return (int) (DateTime.Now - ContractDate).TotalDays;

  10:     }

  11: }

Now I’m screwed, both in testing in code and testing on the site. I’m going to have to create test data with very specific dates, maybe mess around with the values (because I certainly can’t change the clock on the server) and frankly I’m going to cry.

Interfaces can save you here. What if we had an interface called:

   1: interface IDateTime

   2: {

   3:     DateTime Now { get; set; }

   4: }

And instead of the concrete implementation in our customer class we use the IDateTime interface. Here’s the Customer class refactored to use an interface:

   1: class Customer

   2: {

   3:     readonly IDateTime _dateTime;

   4:  

   5:     Customer(IDateTime dateTime)

   6:     {

   7:         _dateTime = dateTime;

   8:     }

   9:  

  10:     public string Name { get; set; }

  11:  

  12:     public IDateTime ContractDate { get; set; }

  13:  

  14:     public int AgeOfContract()

  15:     {

  16:         return (int) (_dateTime.Now - ContractDate).TotalDays;

  17:     }

  18: }

Yes, there’s more that needs to be here like how an IDateTime can subtract values from each other, return a TImeSpan object, etc. but this is just for concepts.

With the interface added, I’m now abstracted away from the concrete implementation of DateTime hard coded into my Customer class. I’ll pass in something that might implement DateTime to return some real time but for testing I can set it to anything I want.

Testing is easier now and I don’t have to change my domain logic to deal with responsibilities outside of my concerns.

Interfaces vs. Classes is the kind of thing to start holy flame wars. Some argue it adds extra code/work to the developer, others claim it unnecessarily future-proofs your app (aka YAGNI) and others think it makes for easier testing and abstraction away from things that have yet to come.

I like to live in the latter world where I build my systems loosely coupled but tightly integrated. Interfaces provide me that ability. I hope this article sheds some light on the subject for you, whatever you choose.

Enjoy.

Literacy

Imagine a world in which very few people knew how to read or write. You kept to parts of town because you couldn't read a map or a street sign. When you needed to sign a contract, you just asked what it said and had to take it on faith. A lot of your experience was based on legend and rumor. Books, and the information in them, was mystical. Sometimes you suspected they were being used against you, but you never really knew.

There was definitely plenty of work around, but some high end jobs weren't remotely possible - not just clerical work, but professions that required a lot of information management, like the medical and legal professions.

Please don't tell me not to learn to code

Over this past year, there have been commentary back and forth on whether everyone should learn to code. A few free, interactive sites like Codecademy popped up which made it easy to start learning some basic coding. I was a big fan - I helped my eleven year old daughter go through it, and we both agreed it was great. More on that later.

Then Codecademy launched Code Year - a grand plan to teach hundreds of thousands of people to code. It was a big hit - even NYC's mayor signed up.

But no good deed goes unpunished, and there's been some snarky criticism from - you guessed it - professional coders. The latest if Jeff Atwood's post, Please Don't Learn To Code.

Hogwash. Learning some basic coding is an excellent investment of anyone's time.

Easy on the Straw Men

It's "please don't hear what I'm not saying" time.

I don't think that the general populace needs to be proficient at writing code. It would be silly to argue Mayor Bloomberg shouldn't be slinging Javascript on the job (as Jeff does). That's not at all the goal. Nobody's saying that everyone should become a programmer.

What I - and others -are saying is that learning some basic coding skills is an excellent investment of anyone's time. I'll make two arguments:

• Understanding computers (including all the computing devices and products that surround us) is of huge and growing benefit to everyone.
• Basic programming is an excellent way to gain some of that understanding.

Computer Literacy as a Basic Life Skill - Right Now

Right now, pretty much every part of life is in some way affected by computers - most pretty heavily. Shopping, socializing, medicine, education, law, entertainment and more are all at the very least affected by computers and the internet. My three daughters had a use for basic computer skills long before math would do them any good.

This only gets more intense with increasing age. Teenagers can greatly profit from computer expertise and tech savvy. It's hard to imagine a college program (at least one with any practical application) that didn't involve a hefty amount of computer usage - from basic internet research and word processing on up to simulation and research.

Most careers (in the industrial world) involve some amount of information management, and workers in these professions who have some computer skill can often be a lot more effective. That includes areas where even a decade ago people might not have expected to see computers - agriculture, construction, family-run restaurants.

I've talked with countless "civilians" who have profited from computer skills over the years - a real estate appraiser who figured out how to automate using Excel and worked circles around his colleagues, film makers and musicians who figured out how to record, market and distribute on the internet, non-techies who sell things online, a school facilities manager who figured out how to cut costs significantly using computer security and automation.

And many of those people had new doors and careers open to them due to their new-found computer skills. When the real estate market slowed down, the appraiser jumped right into a technology job. Heck, learning to code on my own - starting with my grade school's Apple II - gave me the option to jump into a computer career after I got out of the Navy (in a technical but not computer related field).

Computer Literacy as an Absolute Essential in the Very Near Future

"The future is already here — it's just not very evenly distributed."

- William Gibson

It should be obvious to anyone paying attention that computers have become a huge part of our daily lives, and that trend is rapidly accelerating.

I'm reading Physics of the Future (Michio Kaku). It's a fascinating book in which Michio points to obvious trends and extrapolates where things are going in the near future. In many cases, even a very conservative estimate - or even a look around - shows that every part of life will soon involve interacting with computers and the internet. He points out that global powers during World War II would have killed for the computational power in a simple musical birthday card. Now, we just throw them away. Average mobile phones rival supercomputers from the not-too-distant past, and they're connected to a growing internet and GPS satellites. In the next few decades, computers will continue to shrink and become integrated into everything we interact with.

The quality of our everyday lives will be greatly affected by how we interact with computers. How should that interaction take place?

Magical! Or, Should We See Computers as Products or Tools?

Technology companies work hard to package technology so that it can be used naturally, so consumers won't have to think or fiddle with details. This is a good thing. Anyone working in technology should be focused, consumed with the challenge of exposing the possible as the natural. We should be doing this not just because it's a worthy goal, but because it makes good business sense - friendly products sell.

But it is not in the average consumer's interest for them to blindly buy into this magical experience.

Think about the historical progress in how informed consumers approach medicine. In ancient times, mystics sold magic and consumers had no real insight into what they were buying. Over the centuries, the public has gained a much more informed view of science and medicine, and this is of huge benefit to them as consumers. We expect to see evidence, we read about product recalls, and the market for doctors who sell amulets and snake oils is pretty small. This applies to other areas of life, as well. While I could get around in a car I thought was powered by tiny horses, I'd be unlikely to make wise decisions regarding the purchase and repairs to said car. An informed approach to modern life helps.

Now think about the consumer approach to computer products.

Think about how computers and technology are shown in movies and TV.

Think about how helpless your relatives and neighbors feel when they're buying techy products, or when something doesn't work.

Think about a friend or relative who paid too much for a website that never worked right.

Ah, but you may be thinking about a favorite company who sells you magical products right now, or runs some of your favorite websites, or sells you apps or movies. Well marketed brands that have built reputations for quality and ease of use have helped uninformed consumers navigate the technology landscape, but keep in mind that these companies have divided interests. It's their job. They want to sell you things, and their stockholders demand that they bring in as much profit as they can from those sales. Mindless and uninformed brand loyalty is not only expensive, it's by nature counter to your interests. It's no way to live - and thrive - in a digital world.

Computer Literacy as a Leadership Requirement

The basic level of technical understanding that we expect of our leaders must grow with time in order for them to govern. We expect them to understand our legal system, but we also expect they should know that medicines are chemicals which influence the biological processes in our bodies, that electricity powers lightbulbs and is transmitted over an electrical power grid, that mobile phones have radios in them, etc. I'd be scared to hear that our leadership didn't have a very basic understanding of our modern world. They write and enforce laws and policies that greatly impact our lives, so they need to have a clue about the world we live in.

In the same way, leaders who see computers as magic boxes, coders as wizards, and computer code as incantations can't effectively govern. They can't set policy, they can't have informed legal opinions, they have no framework for evaluating whether information being fed to them is makes any sense (or even knowing if they should ask).

Leadership requires understanding, and more, it requires - well, a sense of direction. The future is going to include more and more technology, and leaders who don't understand the present or even have a rough idea of the road ahead are a menace.

Computer Literacy as an Educational Oversight

I've been describing why non-techies can benefit from some computer literacy. Unfortunately, they won't get it in from our schools.

Computer literacy is undoubtedly of more use to most people than the foreign languages most high schools require (I want those 4 years I spent on high school French back). I have rich conversations with people worldwide thanks to the internet and automated translations, not any time I've spent studying languages.

Though it may offend, computer skills are of more use to the huge majority than mathematics including and beyond first year algebra. Most people will rarely if ever use algebra; everyone uses computers.

Consider this: in the off chance that the average farmer / dentist / lawyer / car mechanic / stay at home parent / author / teacher / etc. needs to solve an algebra problem, they can punch it into the search engine and get the answer: 3x + 7y = 4y - 35. Or, more likely, just ask their phone.

The same goes for so many things we devote educational time to. Does the average high school graduate remember anything important about titration or Augustus or sentence diagram? Titian or Taft? Or even remember how WWI started? Does it matter when they can just look it up on Wikipedia?

I'm all in favor a balanced education. I got a B.S. Physics (with honors) from Annapolis and went through the US Navy Nuclear Power program (a very rigorous engineering program) following that. My parents were both school teachers. My wife and I homeschool our daughters and put a very high priority on their education. I see education is important, and I think STEM is an important priority.

But in the broader perspective, our educational priorities are often focused on a historical ideal, completely out of touch with a world in which nearly everyone interacts regularly with computers that most people barely understand.

This is a much bigger discussion, but here's the main takeaway: after thousands of hours in the classroom, our students emerge unempowered into an increasingly digital world. We're on our own here.

Excess Capacity: Oh, the Hours We Throw Away

Fine, most people could benefit from some computer literacy. But who has the time?

I don't buy it. We as a society throw away countless hours on games, entertainment, and apparently even tracking the adventures of someone called Snooki. We make video mashups and silly tumblogs and meme pictures of cats. We catalog Pokémon. We read books about vampires romancing high school girls. We write long blog posts.

We have the time.

We have a ridiculous amount of leisure time, hours we just throw away because we can't think of anything better to do.

Basic Coding as a Gateway To Basic Computer Literacy

While it might make sense, I'm not proposing citizens spend a mandatory two years in the "Get Smart About Computers" corps. I'm just proposing that:

1. Non-techies consider spending a few hours learning how computers work.
2. Techies encouraging them - and not actively discouraging them ! Sheesh!

Thankfully, getting a basic idea of how computers work has gotten incredibly easy. Sites like Codecademy make it easy to learn - hands on - how computers work. These lessons are hands-on, and they're practical. You learn web fundamentals and how to build a simple website. This is empowering stuff. It's a great way to start the journey from a powerless consumer to a contributor, or at least informed consumer. It's not time consuming, and it's free.

Maybe some of the negative reactions from coders to the Code Year phenomenon have come from not bothering to actually read what's in the classes and assuming that the goal was to turn a bunch of people into programmers. Maybe.

Case Study: Rosemary, Champion of the World (and my daughter)

This past year, my daughter asked me if I could teach her computers. I talked to my wife and rolled it into her school plan. We had ten lessons. During this time, we worked did the following:

1. We worked through the Getting Started With Programming section of the Codecademy Javascript Fundamentals course. She did all the work on her own, and when she got stuck I would have her re-read the instructions out loud. She'd say "Oh! I should have read more carefully!" and move on. She learned some basic loops and conditionals - nothing difficult. I gave her at test on repl.it where she wrote a loop from 1 to 25, outputting either "You are too young to drive a car!" or "Your age is 20, you can drive a car!"
2. She asked how the internet works, so we watched a video on YouTube about how the internet works. Then we went on a field trip to our router, and we talked about how to "fix the internet" when it's not working.
3. She asked about making a web page, and how web pages work. We played with browser tools (Chrome and IE) and she learned the difference between HTML, CSS, and Javascript. I let her recolor my webpage pink, and we went to CNN and put her picture and the headline of her choice in the headlines.
4. She asked about making a computer game. We talked about why that would take some work, and planned to do that when we started back up in the semester.

This was fun. We both had a good time. She asked questions that wouldn't have come up otherwise, and she wouldn't have been interested in otherwise.

More importantly, after only 8 or so hours, I noticed she saw the world differently. She had ideas about what computers should do. She laughed when computers did silly things on TV. She read error messages and solved problems in an intelligent way. She keeps asking about building a computer game.

She understands that there's no reason that girls can't have fun with computers, too.

From a time investment of about 8 hours.

This started with writing some Javascript and HTML. That was critical because it helped her understand how computers work. She learned that they were unthinking and unforgiving in the way they followed her instructions. More importantly, she learned that they would do what she told her if she learned their language (in this case, some basic Javascript).

Case Study: The Judge

In a funny bit of timing, just last night I read about the judge on the Oracle / Google trial was able to make an informed decision about a Java function because he'd been -shocker - learning some Java. It was something that would have seemed obvious to most programmers, but was delightfully refreshing to hear in a court.

Now here is a later followup where the Judge slams Oracle:

Judge: We heard the testimony of Mr. Bloch. I couldn't have told you the first thing about Java before this problem. I have done, and still do, a significant amount of programming in other languages. I've written blocks of code like rangeCheck a hundred times before. I could do it, you could do it. The idea that someone would copy that when they could do it themselves just as fast, it was an accident. There's no way you could say that was speeding them along to the marketplace. You're one of the best lawyers in America, how could you even make that kind of argument?

Oracle: I want to come back to rangeCheck.

Judge: rangeCheck! All it does is make sure the numbers you're inputting are within a range, and gives them some sort of exceptional treatment. That witness, when he said a high school student could do it...

So here's a judge who's able to make an informed decision about a technology case. What's more shocking is that this is news.

Some Objections

Shouldn't everyone learn plumbing, too?

Jeff's been having fun equating the "learn to code" movement with "learn plumbing!"

This is one of those fun arguments that sounds good but falls apart after a moment of thought. What would the return on investment be - both in cost and time - for your average person to learn more about plumbing than working a plunger? How often do they work with plumbing in a way that would benefit from a deeper understanding?

How often do most people work with computers, smartphones, and internet sites in a way that would benefit from knowing a bit more?

Not more code! The world needs less code!

This is a bad argument for three reasons:

1. This is a coder's argument to other coders. Solving your application's issues is often best solved by thinking, not mindless coding - granted. That has nothing to do with whether it's worthwhile for your average person to learn about how computers work.
2. It's - perhaps unintentionally - elitist. We nerds have a huge advantage in dealing with the computers that surround us. Telling the rest of the world that they can't join in, or acting like it's harder than it is, is just wrong.
3. It assumes that amateurs won't be writing code anyways. I've seen tons of code over the years written by people who had a problem to solve. They cobbled it together from internet searches. It was inelegant, but it worked in that it solved their problem. There are a lot of populist pseudocoding tools out there - think of ifttt or the use of countless Wordpress plugins - that let real people solve real problems without having to wait for nerds to get involved. They'll do what they need to do, the question is whether we'll encourage them and help them find the structure.

Fine, learn computer literacy, not coding!

This is at least something. The problem here is twofold:

1. It assumes people know what questions to ask, or how to ask them. As long as they see computers and the internet as mystical boxes full of magic, that's not the case. I'm continually helping people solve problems by prompting them to actually read what a program or web page is telling them (and saying that computers and web pages need to give better messages or not require input is irrelevant).
   
   Without knowing the fundamental differences between how computers and people think, people resort to just yelling louder in their own language.
   
2. It assumes we know what people need to learn. That's only kind of true. Often the approaches I've seen here come down to teaching them how to use a particular product or software package, which is definitely not "teaching a man to fish." Real problem solving skills in the technology world come down to thinking systematically and rationally about technology, which requires some basic understanding.

Where Next?

If you don't know how to code, get started. It's free, fun and easy.

If you know how to code, encourage others around you when they want to learn. Odds are, someone did that for you a while back.

I’ve asked this on twitter, and here’s what I got:

• System.IO.Abstractions (looks pretty deep)
• SystemWrapper (I’m not crazy about the file system being used as a mock API)
• Something older

I’d take a look at the first on the list first, if only for it being on github as a sign of advancement.

I’m incredibly excited to announce that I will be joining ifttt starting in June. As you probably know by now, I love APIs and all of the possibilities that they open up. ifttt exemplifies the value of APIs more than any other company that I’ve seen. When I recently started looking for a job, they were on my short list of companies that I wanted to pursue. Things worked out and I’m honored to be joining such a talented team and helping continue to make ifttt great.

If you’re unfamiliar with the service, ifttt allows you to easily connect the services you use in useful ways. For instance, you could automatically save all your Instagram photos to Dropbox. Or save your Twitter favorites to Instapaper. That’s just barely scratching the surface of what’s available, and the company has big plans for the future. You can sign up for free to try it out for yourself.

For those of you who helped me out with introductions and meetings over the past six weeks (you know who you are), thank you for your kindness. It means a lot to me and I hope I can repay the favor in the future.

I'll be doing an eLearning event on HTML5 for Mobile with jQuery Mobile. There will also be a few items sprinkled in on ASP.NET Razor.

Mobile development is a hot item. Customers are buying iPhones, iPads, Android devices, and many other mobile computing devices at an ever increasing record pace. Devices based on iOS and Android are nearly 80 percent of the marketplace. RIM continues to be dominant in the business area across the world. Nokia's growth with Windows Phone will grow on a worldwide basis. At the same time, clearly web development is a tremendous driver of applications, both on the public Internet and on private networks. How can developers target these various mobile platforms with web technologies? Developers can write web applications that take advantage of each mobile platform, but that is a lot of work. Into this space, the jQuery Mobile framework was developed. This eLearning series will provide an overview of mobile web development with jQuery Mobile, a detailed look at what the jQuery Mobile framework provides for us, how we can customize jQuery Mobile, and how we can use jQuery Mobile inside of ASP.NET.

Read More

While I was at the QCon conference in London a couple of months ago, it seemed that every talk included some snarky remarks about Object/Relational mapping (ORM) tools. I guess I should read the conference emails sent to speakers more carefully, doubtless there was something in there telling us all to heap scorn upon ORMs at least once every 45 minutes. But as you can tell, I want to push back a bit against this ORM hate - because I think a lot of it is unwarranted.

-- Martin Fowler

Read the rest of the ORMHate post here:
http://martinfowler.com/bliki/OrmHate.html

Am 16. Juni 2012 findet erstmalig die Spartakiade-Konferenz in Berlin statt. Hinter dieser Konferenz, deren Name Assoziationen zu Sport-veranstaltungen wecken soll, stehen mit Daniel Fisher, Kostja Klein, Jan Fellien, Michael Willers, Mike Bild und Torsten Weber als Veranstalter bekannte Namen aus der .NET Community.

Die Konferenz

Die Spartakiade stellt eine Ergänzung zu “Übersichts”-Konferenzen wie z.B. der dotnet Cologne mit ihren 60-Minuten-Sessions und der klassischen Rollenaufteilung in Sprecher und Zuhörer dar. Ziel ist es, einige wenige Themen ausführlich zu behandeln und vor allem dabei auch die Teilnehmer aktiv werden zu lassen. Der Sportmetapher folgend werden aus Sprechern “Trainer” und aus Teilnehmern “Sportler” – und Sportler bekommen ja auch nicht vom bloßen Zuhören automatisch Muskeln… 

Der geplante Ablauf der Konferenz ist wie folgt:

• Die “Trainer” stellen ihre Sessions in jeweils 10 Minuten kurz vor.
• Dann finden sich “Teams”, die sich drei Stunden mit dem jeweiligen Thema beschäftigen.
• Die Teams stellen ihre Zwischenergebnisse vor.
• Es folgt eine weiterer Durchlauf.
• Zum Schluss werden die Endergebnisse erneut vorgestellt.

Die Konferenz ist im Prinzip kostenlos, wie beim .NET Open Space können die Teilnehmer freiwillig entscheiden, ob sie die Veranstaltung durch eine Spende unterstützen wollen.

Die offizielle Website ist http://spartakiade.org/2012/

Die Themen

Das Kernthema der diesjährigen Konferenz heißt “Design”, geboten werden u.a. die Sessions Spieleentwicklung, HTML5, Lightswitch, MVVM, Windows 8 und Windows Phone, in denen die Teilnehmer auch selbst programmieren.

Der UI/UX Workshop

Ich freue mich dass ich das Angebot erhalten habe, ebenfalls als Trainer teilzunehmen, obwohl (oder evtl. gerade weil?) bei mir keine Zeile Code geschrieben wird.

Folgendes habe ich für meine – auch für selbsterklärete GUI-Laien geeignete – Session geplant:

• Zum Einstieg gibt es nach einer Einführung in die menschliche Wahrnehmung einen Crash-Kurs in visuellem Design.
• Dann geht es beim Thema “Darstellung” um eine analytische Betrachtung dessen, was überhaupt angezeigt werden soll und welche praktischen Auswirkungen das auf die konkrete Gestaltung haben kann.
• Ganz emotional wird es, wenn es um User Experience geht. Dazu gehören auch Feinheiten wie z.B. der Ton, in dem Texte formuliert sind und der darüber entscheiden kann, ob sich Anwender ermutigt oder eingeschüchtert fühlen.
• Mit diesen Grundlagen im Gepäck geht es dann an konkrete GUIs und komplexere Interaktionen.

Alle Punkte werden jeweils durch praktische Übungen begleitet. Beim UI Sketching nehmen die Teilnehmer Stift und Papier in die Hand – und mancher wird erstaunt sein, wie effektiv diese "analoge" Art des Arbeitens sein kann.

Die Teilnehmer sind aufgefordert, eigene GUI-Beispiele mitzubringen, die dann in gemeinsamen Diskussionen auf Stärken und Schwächen untersucht werden können. Warum funktioniert eine bestimmte Lösung? Warum hat eine GUI einen guten Ersteindruck hinterlassen (unabhängig davon, ob sie langfristig tatsächlich so praktisch ist wie gedacht)? Welche Schwachpunkte in einer GUI könnte man durch Detailverbesserungen angehen? Und an welcher Stelle sollte man über ein neues mentales Modell nachdenken?

Je nach verfügbarer Zeit und Interesse der Teilnehmer kann zum Schluss gemeinsam die GUI für eine Anwendung mit einer selbstgewählten Aufgabenstellung konzeptioniert werden.

Es wird spannend!

Vieles auf der Konferenz ist eine Premiere; für mich persönlich ist der Workshop in dieser Form auch etwas Neues. Das grundlegende Folienmaterial habe ich im Laufe der letzten Jahre zusammengetragen und bereits häufig in meinen Vorträgen in User Groups und auf Konferenzen vorgestellt.

Bei den interaktiven Teilen weiß ich hingegen nicht, was mich erwartet. Aber nach den Erfahrungen aus meiner täglichen Arbeit bei der Konzeption von GUIs freue ich mich auf viele spannende Diskussionen und interessante Lösungsansätze.

Wir sehen uns in Berlin!

Let’s face it. NetMsmq is the bastard child amongst the WCF bindings. Many WCF developers just resort to the default Request/Response paradigm and the BasicHttpBinding or WsHttpBinding. Of course, queuing and One-Way Asynchronous Messaging can be a powerful instrument in your service designs. But many ignore it. Thus there isn’t much out there about the NetMsmqBinding, especially when hosted in WAS (even worse when deployed to multiple servers). The notable exception is Tom Hollander’s excellent MSMQ, WCF and IIS: Getting Them to Play Nice Together. Recently, I had course to spend some quality intimate time with NetMsmq and WAS and was surprised at how hard it was and how many places one can trip up.

Just a little aside: I had reported, that in my role the last year and 1/4, I had become a Web Developer and no sign of WCF but recently WCF has become my sole attention for the last few weeks as we gauge it it’s suitability for our Service Layer in a new project.

Here’s a sort of list of the getting all the moving parts working together:

1. You need to first enable WAS so that it can host TCP. Bring up Control Panel – Turn On Windows Features and ensure that Windows Communication Foundation HTTP Activation and Non-HTTP Activation are checked for the Microsoft .NET Framework
2. In the same place, ensure that the Windows Process Activation Services (WAS) is enabled. The checkbox is entitled Windows Process Activation Services and check both items underneath it
3. Well, of course, you can’t have MSMQ without installing/enabling it. So, in the same place, enable MSMQ checking Microsoft Message Queue (MSMQ) Server Core and Active Directory Support as well as MSMQ HTTP support.
4.   On each IIS WAS server to use MSMQ, bring up IIS Manager
5. In IIS Manager, in the Connections pane, expand that connection to the computer, expand Sites, right-click Default Web Site, and then Edit Bindings. If WAS has been installed correctly, it should list the default protocol bindings for the Web site – net.msmq should be listed there.
6.  Close the Site Bindings dialog.
7. In the Connections pane, expand the Default Web Site item, and then choose YOUR Web Application/Service
8.  In the Actions pane (on the right side), click Advanced Settings
9. In the Advanced Settings dialog box, add a comma (,) and the text net.msmq to the Enabled Protocols box
10. Here’s the tricky part. You have to create a queue now for communications. You can usually call a queue whatever you feel like it. But as Tom points out, however, when you are hosting your MSMQ-enabled service in IIS 7 WAS, the queue name MUST match the URI of your service’s SVC file. For example:  if the application name in IIS is PortalLoadSimServices with an SVC file called MSMQService.svc, then the queue must be called PortalLoadSimServices/MSMQService.svc.
11. He also explains why all queues used for WCF should be private.
12. In the Computer Management application, expand Message Queuing. Right-click Private Queues and select New | Private Queue.

13. Type in the name of the queue.

14. The next step is very important and if not done correctly, will be the source of many obscure MSMQ errors. You must enable secure access to the queue for NETWORK SERVICE and Authenticated Users service accounts by right-clicking Properties

15. Implement the code

16. If you don’t have any HTTP endpoints, you may have to publish a Metadata Exchange Protocol (MEX) endpoint to serve up metadata so you can generate the proxy. The following shows that as well as declaration of the NetMsmq endpoint

<service name="Portal.LoadSim.Services.MsmqService">

    <host>

      <baseAddresses>

        <add baseAddress="http://localhost:8000/PortalLoadSimServices10/MsmqService"/>

      </baseAddresses>

      </host>

      <!-- Define NetMsmqEndpoint -->

        <endpoint address="net.msmq://localhost/private/PortalLoadSimServices10/MsmqService.svc"    binding="netMsmqBinding" bindingConfiguration="MsmqBindingNonTransactionalNoSecurity" contract="Portal.LoadSim.Shared.IMsmqService" />

        <!-- the mex endpoint is exposed at http://localhost:8000/PortalLoadSimServices10/MsmqService/mex -->

<endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange" />

 

17. Ensure the NetMSMQ Listener Adapter is turned on in the Services panel! I can’t tell you how many times I got cryptic errors like the queue permissions are incorrect when it turned out the Listener wasn’t on!

 

Well, I hope this helps other people out.

 

I’ve started getting into Windows Server 2012 and IIS 8 (currently beta 2).  It’s not as exciting today with all the other technology things happening in the world.   The quality of beta’s are worlds better than early days of betas, evaluating doesn’t take as long.   Here are a few things I wanted to pass along. 

Windows Server 2012 comes in three variations

1) Server Core – No GUI (Linux guys rolling their eyes now )

2) Server Core with Minimal GUI (Server Manager, Event viewer, IIS Manager, among other things, No Explorer, No Control Panel, No IE)  (Linux guys still rolling their eyes)

3) Server with FULL GUI (Windows guys without a start button)

Powershell 3.0 on Win2012 offers 10x amount of cmdlets, 2300+ mentioned at MMS 2012.  With #2, you need to think differently how machines are setup and administered.  The concept of logging into the server, browsing locally to see what the error is can’t happen, there is no IE!  I’m realizing Windows admins RDP to boxes, *nix guys SSH.

Troubleshooting .NET applications require a little different mentality.  Today, people set <customErrors to RemoteOnly), so when you are on the local system, you can see the full error.  .NET offers the option to show errors in various levels, which is necessary to see the raw error, or have rich enough logging to capture the error, write to a central database.  Whatever option you chose is something to think about.   Here is a few articles to think about.

http://weblogs.asp.net/scottgu/archive/2006/08/12/Tip_2F00_Trick_3A00_-Show-Detailed-Error-Messages-to-Developers.aspx

http://weblogs.asp.net/owscott/archive/2010/07/29/troubleshoot-asp-net-errors-remotely-while-appearing-local.aspx

http://forums.iis.net/p/1149471/1870011.aspx

Another new feature is generating PowerShell IIS commands has been built into Configuration Editor.  To use the PowerShell, import the WebAdministration module 

http://technet.microsoft.com/en-us/library/ee790599.aspx

Some tips/tricks

When you are installing the OS, there is two options.  I chose Server Core #1, then run the following command to add the minimal GUI

Add-WindowsFeature -Name Server-GUI-Mgmt-Infra

Here is how to DISABLE UAC

Please follow steps in below link to disable UAC.

How to disable UAC: http://social.technet.microsoft.com/forums/en-US/winserversecurity/thread/0aeac9d8-3591-4294-b13e-825705b27730/

===============================================================

The best way is to change the registry key at registry::HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\policies\system; key = EnableLUA

You can use the following powershell code to check the value:

Code Snippet

$UAC = Get-ItemProperty -Path registry::HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\policies\system -Name EnableLUA

$UAC.EnableLUA

To change the value and disable UAC:

Code Snippet

Set-ItemProperty -Path registry::HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\policies\system -Name EnableLUA -Value 0

You need to reboot to make it take effect.

===============================================================

Enable Remote Desktop (Only needed on minimal install)

http://blogs.technet.com/b/mempson/archive/2008/03/11/enable-remote-desktop-via-the-registry.aspx

These are few basic things which I hope help your evaluation of IIS8 and Windows Server 2012.  

Enjoy,

Steve Schofield
Microsoft MVP – IIS

I have been working on a Windows Phone application for the user group that I help to run and have been experiencing head ache after head ache.  The problem isn’t the Windows Phone development itself.  The issues are with the external web service APIs that I am trying to use for sites like SlideShare and Box.net. 

The main issue is that while there is a lot of documentation and examples for the output of the APIs, the input format is sketchy at best.  The web service for SlideShare, for example, requires that a set of values be hashed using SHA1, but there is not example of what the format of those values should be prior to being hashed.  That mean there is a lot of head bashing trial and error and error and error. 

Anyone who publishes a public API should realize that users of that API are not going to have knowledge of the internal workings of their product (and shouldn’t).  You can’t even expect them to have the same tools either.  Given that this is a web service being used the calling applications could be on any number of platforms using an equally large number of languages.  The only way to ensure proper usage of your tools is to explicitly document the parameters of your interfaces and mountains of examples.  The easier you make it for developers to code against the greater the adoption will be for your API.  Let’s all remember this going forward.

At my employer we have a local NuGet server to host all of our internal packages. Occasionally, I’ll be working on a project and realize that I need to tweak something in one of  my NuGet packages. Initially, I got into the habit of  opening up a second instance of Visual Studio, making the necessary changes and using the NuGet web interface to re-upload the package. I quickly realized that manually uploading the package was too time consuming. Therefore, I started looking for a way to automate the process instead. Eventually that led me to the PowerShell script you see below.

$nugetServer = "https://<your nuget server here>"
$apiKey = "<your api key here>"
$packageName = "<your package name here>"

$latestRelease = nuget list $packageName
$version = $latestRelease.split(" ")[1];

$versionTokens = $version.split(".")
$buildNumber = [System.Double]::Parse($versionTokens[$versionTokens.Count -1]) 
$versionTokens[$versionTokens.Count -1] = $buildNumber +1
$newVersion = [string]::join('.', $versionTokens)
echo $newVersion

get-childitem | where {$_.extension -eq ".nupkg"} | foreach ($_) {remove-item $_.fullname}
nuget pack -Version $newVersion
$package = get-childitem | where {$_.extension -eq ".nupkg"}
nuget push -Source $nugetServer $package $apiKey

The script needs a few variables defined in order for it to run. The first variable ($nugetServer) is the URL of the NuGet Server. The second variable ($apiKey) is your personal API key. You can get your API key by logging into your NuGet Server with a browser. After you log in, click on your username in the upper right hand corner. This will take you to your account page. On the bottom of the “My Account” page there is a box which you can click on to make your API key visible. Finally the last variable ($packageName) is the name of the package you are uploading. This can be easily acquired by looking at your project properties and copying the Assembly name from the Application tab.

Depending on how your machine is configured you may have the option to Run with PowerShell on your context menu. If not, you can take a look at this blog post in order to configure it manually. Alternatively you can use the following command instead.

powershell.exe "<path to the script>\publish.ps1"

If you have any problems running the script then please refer to the following TechNet article or send me a question and I’ll be glad to help.

Fiddler is a popular web traffic debugging tool which lets you inspect web requests.  This ability is very helpful when developing applications which consume web services.  I’ve been working with a team on an Android application and I needed to use Fiddler with Android.  In this post, I’m going to show you how to setup Fiddler to inspect web traffic from an Android device running Ice Cream Sandwich.

1) First, if you don’t have Fiddler yet, you can download it here.

2) Second, you need to set and take note of some Fiddler options.  Check the “Allow remote computers to connect”.  This option will allow your Android device to connect to Fiddler via your computer’s local IP address and proxy port.  You can see and/or configure what port Fiddler listens on as shown below.  The default proxy port is 8888.

3) Restart Fiddler so that it loads your new configuration options.

4) Next, you’ll need to setup your Android device to run it’s connectivity through Fiddler.  Navigate to Settings >> Wireless & Networks >> WiFi.  Select the network you are using.  If you are debugging your Android application, you’ll probably be using your local wireless connection.

5) Enter the basic settings and check “Show Advanced Options”.

6)  Under Proxy Settings, select “Manual” so we can manually enter the IP address & proxy port which Fiddler is running on.

7) Enter the IP Address and Proxy Port information where Fiddler is running.  Most likely Fiddler will be running on your local development machine.  If using Windows, you can find your IP address by going to the command prompt and using ipconfig (Start >> Run >> “cmd” >> “ipconfig”).

That’s all there is to it.  After you have this setup, make sure that Fiddler is running and web traffic from your Android device should be routed through Fiddler.  Happy web traffic inspecting!

Yesterday I had the pleasure to attend and present at the SharePoint Saturday Belgium edition. The Belgium Information Worker Usergroup (BIWUG), who organized the event, deserves a big round of applause; they hosted around 200 enthusiastic SharePoint people on a free and fun event. Of course a big thanks also goes to the numerous sponsors: Xylos (for making their great infrastructure available), AvePoint, Beyond-it, Metalogix, K2, Microsoft, Spikes, Ventigrate, Aurelium, Axceler, CTG, Idera, RealDolmen, Webtrends, and Wrox.

On top of that Karine and Andy released their first public beta version of the brand new CAML Designer tool (think of it as newer, stronger and better successor of the U2U CAML Builder). You can find it on the BIWUG site.

You can get my PowerPoint presentation about the SharePoint Designer below. See you all next time, or on one of the next BIWUG meetings!

I described the “typed factory” concept here some days ago. The solution we looked at was requiring the Castle DynamicProxy dependency. If you want something simpler zero dependency and “just working” I creted a little hacking factory: AnyFactory. It is really simple and does not requires any external dependency, and can be integrated in your project by just adding a single file. I provided some documentation on the project wiki. The extension works by crafting a factory implementation using Reflection.Emit. It does not requires to configure anything since a unresolved dependency satisfying some restrictive rule is considered to be a factory, and the implementation is produced in the background.

the rules for an interface to be consider a factory are:

• It is a public interface
• Each method name starts with Create
• Each method return something
• There is no properties

The name is required to begin with Create, if it contains something after Create, this is considered to be a named binding to solve. Construction parameters can be specified, but there is a restriction: the parameter name should match the implementation constructor parameter name. ANother limitation is that we don’t support the “delegate” factory.

Op 12 en 13 april 2012 heeft Microsoft Nederland in de Fabrique in Maarssen het Windows 8 Developer & User Experience Design Camp georganiseerd. Het was een druk bezocht evenement waarbij er een bijna 50/50 mix was van developers en designers.

De eerste dag bestond uit een programma van sessies, waarbij er ook breakouts waren voor developers en voor designers. Hiervan heb ik 2 sessies mogen verzorgen. Deze sessies zijn opgenomen en staan nu online op Channel9.

Het bouwen van een Metro style app

Deze sessie laat zien hoe met XAML, C# en WinRT een Metro style applicatie voor Windows 8 gebouwd kan worden. Er wordt getoond wat de veranderingen en toevoegingen zijn in Windows 8. Denk hierbij aan asynchroon programmeren en andere technieken die de kwaliteit van Metro style apps zullen verhogen.

Laat je Metro style app leven door tiles en notificaties

Gebruikers worden als het ware naar een app toegetrokken door het gebruik van actieve tiles op het start scherm. Notificaties die door de Windows Push Notification Service verstuurd kunnen worden, kunnen gebruikers weer de aandacht vestigen op een app zonder dat die actief is. In deze sessie wordt verteld hoe tiles en notificaties gebruikt kunnen worden. Er wordt ook geleerd hoe een tile een deep link naar specifieke informatie in een app kan verzorgen

Overige sessies

• Een overzicht van het Windows 8 platform (Matthijs Hoekstra – Microsoft)
• Metro style design (Martin Tirion – Microsoft)
• Integreer met Windows 8 door het gebruik van contracten (Thomas Huijer – Oosterkamp Training)
• Hoe een Metro style app te optimaliseren voor touch (Martin Tirion – Microsoft)
• Van een website naar een Metro style app – een case study (Eva Muller – Microsoft)

Cheers,

Fons