It was an interesting challenge.

public class Course
{
public int room;
public string name;
public Course(int room, string name)
{
this.room = room;
this.name = name;
}
}
public interface Role
{
string Name { get; }
}
public class StudentRole : Role
{
public string Name {
get { return “Student”; }
}
}
public class LecturerRole : Role
{
public string Name {
get { return “Lecturer”; }
}
}
public class JanitorRole : Role
{
public string Name {
get { return “Janitor”; }
}
}

public class CourseAttending
{
Course course;
Role[] roles;
public CourseAttending(Course course, Role[] roles)
{
this.course = course;
this.roles = roles;
}
}
public class Person
{
public string name;
public CourseAttending[] coursesAttending;
public Person(string name)
{
this.name = name;
}
}

public void Main()
{
Person person = new Person(“John”);
Course course = new Course(101, “WWW”);
person.coursesAttending = new CourseAttending[] { new CourseAttending(course, new Role[] {
new StudentRole(),
new LecturerRole()
}) };
}

Can’t develop without it… Thanks

The problem with these tests is that it’s treating the process backwards. If you want someone who is really good at what they do, no matter what discipline you’re hiring, they have to choose to work for you. You want it to be as easy as possible for them to find you and get through the interview process while still filtering out the people you don’t want. Good people do not need a job, they already have one. The more hoops you make them jump through the less likely they’ll bother to keep going. This is why tests like ‘reverse a string’ or fizzbuzz are great. They’re easy to understand, fast to implement, and shouldn’t require any outside resources if you allow the interviewee to use whatever language they want. Then you give them a complex problem and have them work through some general design and implementation ideas without talking about code to make sure they can manage some high-level design. Between these 2 types of tests you should be able to filter out the non-programmers while not putting up too many roadblocks to deter someone who needs to choose to work for you.

Also if IoC is configuration driven, then you’ll have to cycle your process anyway, to make your configuration changes active. How would you resolve this?

In a scripting language environment where all the objects live in some sort of global container this makes a lot of sense – you don’t even need to have name bindings in such a setup. Unfortunately in .NET this is not the case. And unless you explicitly expose the gut pieces you would be interested to look from the start you are in trouble. There is no good way of saying “give me variable at the state it is now” unless you somehow collected/referenced this variable beforehand for the purpose of exposing it via your backdoor. And then you have all sort of problems with garbage not being collected (weak references, anyone?) memory leaks, and concurrency issues if you modify any values on the fly and locking issues if any synchronization is involved.

Imagine and asp.net application where all the state is quire short-lived (as long as a request is being processed) what then?

Overall it is an interesting idea, but I’d love to hear how the problems above can be addressed to make the idea practical.

I was thinking what happens when you have Aaron on the left of Carol (I mean everything in the example seems so orderly and simple without loopholes). A better example detail explanation for me at least is the bigger set of array of numbers and not as orderly initial set like the one found in

http://www.algolist.net/Algorithms/Sorting/Quicksort

It’s the partitioning that I was confuse about.

I would avoid the standard floating-point based algorithms because they might yield a result whose uncertainty happened to straddle a x.xx5 boundary, which I’d need to correct and/or check for explicitly, complicating things beyond what a quick test of basic programming ability ought to require.

If a linear search were deemed too inefficient, I’d probably escalate to integer bisection to find the right N in N*0.01-0.005.

(No, actually my FIRST first instinct would be
10 PRINT “2.16″
given that the program takes no input anyway and I already know the correct output).

Another difference is ‘learnt’ vs ‘understanding’, I remember for one of my Engineering Degree examinations, I had a brain freeze and forgot all the important equations (Mathematical Modelling and Analysis of Mechanical Systems). Lucky for me I understood the topic enough to derive the equations from first principles.

Further, to add being a ‘Girl’ is logically irrelevant!

PS apologies about my grammar, English is only my third language. I only learnt to read/write English in two weeks.

Sure I learnt about LASER theory and built radio’s when I was only seven BUT I thats only because I had learnt to do that.

So the real question is not what you how to solve, its how you solve what you don’t know.