Filip Ekberg's blog

Use Test Driven Development to verify that the code will Always work!

Filip Ekberg — Fri, 23 Apr 2010 11:51:54 +0000

After attending Scandinavian Developer Conference in Sweden 2010 and attending the talk from Roy Osherove ( http://osherove.com/ ) Test Driven Development ( TDD ) has been something that I have tried to focus a bit more on.

Roy talks about some really important aspects of programming that should be printed into the programmers brain. I for instance is one of these people that like to verify everything that I do; Did I Really lock the door? So when I’ve turned the keys in the lock, I verify that the locking mechanizm worked and that the door is no indeed locked.

So what does my weird habbit have to do with TDD?

Driving the development with tests is not the only part of TDD; as with anything else there are a lot of people that like to think a lot of different things about this method. I like to think of tests as a way to Verify that my code runs as expected.

This is not a case of miss-trust!

Don’t missunderstand the above as see me as someone that does’t trust anyone or anything created by others than myself, that’s not the case. But by verifying that things runs properly, the door is properly locked I know that everything is OK from my part in the scenario.

What if I didn’t run the tests on the code and handed it over to the next developer that Did not in fact know that the method he works in affects everything else? And what if I didn’t verify the lock; I was in a big hurry and someone just went into the appartment and stole my TV?

In my opinion, test driven development is way to:

Verify that Code runs as it should
Decrease mistakes in the future
Help others gain knowledge of parts in the code faster

To take the locking mechanizm-checking even further and really turn it into something that is Driven you can follow these three very simple steps that Roy also talks about in his speeches:

Make it fail
Make it work
Make it better

How do you make the lock fail to lock? Well you simply Don’t lock it!

So let’s head over to the development aspect of this, you want to make your code fail? No code means it will fail right? When I do this step 1 and 2 always go together, especially when I demo TDD for co-workers or others. I will use the same good example as Roy used in his demo on SDC 2010, let’s try to put our heads around a simple Calculator project.

Defining the requirements

For this “project” we only have fourrequirements:

A method called Sum
This method parses a String
This method should return String.Empty when you pass Invalid or Empty data
Adds two integers in the String together “1 1″ would be 2

So if we follow the above we would end up with a test that looks like the following:

1
2
3
4
5
6
7
8
9

[TestMethod]
public void Sum_EmtpyString_ReturnsZero()
{
var calculator = Calculator.GetInstance();
var actual = calculator.Sum("");
var expected = string.Empty();

Assert.AreEqual(expected, actual);
}

Since we haven’t really implemented Calculator, GetInstance or Sum yet, we made it fail, there is no Code. Visual Studio helps us out a bit and makes the process a bit faster, by simply pressing alt + enter when selecting Calculator or Sum we can select to create the Class and create the Method Stub.

So we actually finished both Step 1 and Step 2 at the same time, even though Step 2 isn’t complete yet, we are nearly there!

Now we need to make it work, what is the simpliest way possible to make it work for the above test-case?

1
2
3
4

public string Sum(string input)
{
return string.Emtpy();
}

This will actually work and it will indeed check this test as Passed. But it’s not really what we want. So how do we proceed?

Another Great point Roy pointed out is that, if there isn’t a test, there’s no code and if there’s code there’s gotta be a test! And if one test passes and you want to Change the code to behave different with other input; You need to prove it with a test!

So we can test if

Sum("1")

will return 1, which we from looking at the code will see that it wont!

1
2
3
4
5
6
7
8

public void Sum_ValueContainsADigit_ReturnTheDigitThatIsPassed()
{
var calculator = Calculator.GetInstance();
var actual = calculator.Sum("1");
var expected = "1";

Assert.AreEqaul(expected, actual);
}

This test will most defently fail because of our implementation! So we need to go back to Sum and change this method.

Once all tests passes and the test case is approved, we head on to the next step, which is make it better! In other wors we need to refactor some code! Try to follow these steps to refactor ( i use ReSharper, which is a Great tool! ).

Move the Library to an appropriet Class Library / Project
Optimize the code
Refactor your test to look better
Comment the code

So you got a little peek at what TDD is and how it can be used, if everyone would use TDD, it would be so much easier to take on new projects that have already been started. You never know what your changes will impact on.

Using Parallel Extensions in LINQ

Filip Ekberg — Thu, 25 Mar 2010 14:16:02 +0000

Once again, there was a little mistake in the last post I posted here which clearly didn’t effect the result that much. But it is still worth mentioning again. The ^ was not meant to be XOR, I was clearly thinking of Math.Pow.

In the last post I didn’t spend to much time talking about the Parallel Extensions for LINQ which are Really great and helpful; If you just love to replace traditional loops with LINQ-expressions you will probably find this post somewhat amusing.

So let’s dig down to the coding shall we!

First of all I have set up a smaller list with numbers, in this scenario we will just assume that we have a list of something and depending on the contents of that list, the time it takes to perform an action on that result, will differ. So here’s my list

1	var latency = new[] {1, 2, 4, 8};

Side note: new[]{} is really helpful, especially when you are creating examples like this!

And then I have a method that I want to run for each element in my list, which I will call PerformLogic

1
2
3
4
5
6
7
8

static int PerformLogic(int latency)
{
var ms = 500 * latency;

Thread.Sleep(ms);

return ms;
}

In “traditional” programming, you would maybe do something like this:

1
2
3
4

for ( int i = 0; i < latency.Lenght; i++ )
{
PerformAction(i);
}

But I don’t find that so amusing anymore, using LINQ is so much neater so instead of that for-loop we can actually do this:

1	(from i in latency select PerformAction(i)).ToList();

We don’t really have to write the expession like this though, since LINQ + .NET 4.0 is so smart, we can Refactor this to look somewhat like this:

1	(latency.Select(PerformLogic)).ToList();

The previous one is a bit more elaborate but this is fine aswell.

Making it parallel

We’ve reached the place where we no longer can refactor our code to make it faster, we can’t replace anything in the logic to make everything faster; We need to parallelize it!

Let’s have a look at what LINQ provides us with, oh, there’s an method called

1	.AsParallel

All I did now was changing the above code to this:

1	var result = (latency.Select(PerformLogic)).AsParallel().ToList();

And we have a parallelized query. For those with a fast mind can see that it will take about 7,5 seconds to run this since each of the “latency”-points will take itself times ½ second.

My final test-code looks like this

1
2
3
4
5
6
7
8
9
10
11

var latency = new[] {1, 2, 4, 8};

var start = DateTime.Now;

var result = (latency.Select(PerformLogic)).AsParallel().ToList();

var end = DateTime.Now;

Parallel.ForEach(result, Console.WriteLine);

Console.WriteLine("Execution time: {0}", (end - start));

And this is the output

Using the Parallel Extensions in .NET 4.0 with C#

Filip Ekberg — Wed, 24 Mar 2010 08:59:40 +0000

As .NET 4.0 will be released in a couple of weeks and the RC has been out for a while. It’s about time that I write something about the new helpful features of .NET 4.0. One of these helpful things are the Parallel Extensions and Parallel helpers that allowes you to do parallel programming.

Parallel computing is a form of computation in which many calculations are carried out simultaneously

In this example I will be using a WebRequestPool which just helps me out a bit to carry on this example. You might think if it like this: You have different request types which takes different long to execute you might be doing some WebDAV uploading, Image Fetching and other Over-The-Web-Access which takes time. Instead of waiting for each request to stop, you might as well run them simultaneously.

1
2
3
4
5
6

internal delegate void WebRequest(int ms);

internal class WebRequestPool
{
public List Requests { get; set; }
}

So to make it easy I just have a simple Delegate which will allow us to Run/Invoke our WebMethods which all takes some input parameter that will, in some way, make the requests take longer / shorter.

Inside of the WebRequest class all we have is a Requests Pool, a simple list of delegates.

To make the whole a little bit interesting we have three different types of Requests: Standard Request, Long Request and ExtremeRequest

1
2
3
4
5
6
7
8
9
10
11
12
13
14

static void StandardRequest(int ms)
{
Thread.Sleep(ms);
}

static void LongRequest(int ms)
{
Thread.Sleep(ms^2);
}

static void ExtremeRequest(int ms)
{
Thread.Sleep(ms^10);
}

So now we have three different types of methods that all validate with our delegate! Let’s head on and fire up this pool

1
2
3
4
5
6
7
8
9
10
11
12
13

var pool = new WebRequestPool
{
Requests =
new List
{
StandardRequest,
LongRequest,
ExtremeRequest,
StandardRequest,
LongRequest,
ExtremeRequest
}
};

This actually demonstrates something new too, the object initializers. So the list now contains six requests, All we want to do now is Processes these.

First of all we want to do it like we did in the old days, so I’ve created a method called ProcessPool which looks like this

1
2
3
4
5
6
7
8
9
10
11
12
13
14

private static void ProcessPool(WebRequestPool pool)
{
var start = DateTime.Now;

foreach (var item in pool.Requests)
item.Invoke(2000);

var end = DateTime.Now;

var span = end - start;

Console.WriteLine(
string.Format("Execution time: {0}", span));
}

Of we run this the output is

Now, that’s a bit too slow for me, so Let’s Parallelize that! All i’ve done now is to creat a new method called ProcessPoolAsParallel which takes the same input and expects to give the same result. There’s a little bit difference though, the foreach is now replaced with the

1	Parallel.ForEach

method.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

private static void ProcessPoolAsParallel(WebRequestPool pool)
{

var start = DateTime.Now;

Parallel.ForEach(pool.Requests,
item => item.Invoke(2000));

var end = DateTime.Now;

var span = end - start;

Console.WriteLine(
string.Format("Execution time: {0}", span));
}

So if we run this now the result is:

So this increased significally!

This is just a small example of the power in using Parallel programming patterns. Look into the Task class to head on!

Edit

There’s a slightly miss-used method in the code above, the ^ in C# is XOR and I was thinking of the Math.Pow, however, this doesn’t really matter in this case since the result is still Parallel = Faster.

Function pointers in C and Python and their possible usage

Filip Ekberg — Mon, 30 Nov 2009 15:07:20 +0000

Function pointers? you might ask yourself, well this little trick gets handy sometimes, I will provide an example of a practical use in a later post on the next euler solution. Might actually do it in C too just to prove that C is still neat.

So to kick this off, what are function pointers? Well for those deep down the rabbit hole ( .NET guys that is ), might not really have a clue on the matter, and others might dissaggree and now exactly what it is. So just to keep the air clear here, function pointers are “pointers” that direct you to a function, easy huh?

Well, you probably got as much from just reading the phrase but, it’s not really rocket science. If you are familiar with references or reference types, such as Strings and Objects, you know that there are different types of memory in which your program operates. When you create an Object you store your data on a shared memory place. There are shared memory and program reserved memory ( the stack! ). So you might want to look at this as a “reference” to a function.

So when would this be nessecary? Imagine the scenario where you might want to performe some calculation but you don’t know what type of API the end user which will end up using your API have. Let’s say that the method “square” ( x^x ) would not be defined. So you might end up having to use function pointers, where you ask the user to suppy the function for calculating square of x.

In Python the Square function for x^x will look like this

1
2
3
4
5
6

def square(i):
result = i;
for x in range(i-1):
result *= i

return result

In C it will look like this

1
2
3
4
5
6
7
8
9
10
11
12

int square(int i)
{
int result = i;
int x = 1;

for ( x = 1; x < i; x++ )
{
result *= i;
}

return result;
}

Now these two look fairly similar don’t they? Well sure, the only real difference is the dialekt right? It’s just programming. So let’s get to the cool parts. In python, we would solve this problem easy, since it’s not a strongly typed language everything could be a function, right. So let’s check the decleration for calculate.

But before we check that out, let’s just make it clear that our Usage will be somewhat like, give me a function that calculates square of a+b, this means, the result should be (a+b)^(a+b).

So this is the function decleration in Python

1	def calculate(func, a, b)

Not that hard, right? Well, keep in mind that Python is a “modern” language, it’s more of a scripting language.

Check this out and notice the fairly big difference

1	int calculate(int (*func)(int c), int a, int b)

If you are not familiar with pointers I would suggest you dig down the archive on my blog and check out the chapters about that. So what this really does in C is that you tell the compiler that, okay this function takes a pointer to something that will look like this, and you write the declaration of the function again. So, in this case you really need to know what it looks like. With standard parameter values in Python you could acheive some really cool things without knowing the decleration of the function.

Now we’ve seen how to Create the methods, taking arguments that are functions, how about using them inside your code?

Check this C example of the whole Calculate function

1
2
3
4

int calculate(int (*func)(int c), int a, int b)
{
return (*func)(a+b);
}

And in Python the following will look like this

1 2	def calculate(func, a, b): return func(a+b);

There is a notable difference here, but I can honestly say that I like the C-style.

Try out the python version!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#!/usr/bin/python

def square(i):
result = i;
for x in range(i-1):
result *= i

return result

def calculate(func, a, b):
return func(a+b);

def main():
print calculate(square, 1, 1)

if __name__ == "__main__":
main()

Happy Coding!

Solving the first problem

Filip Ekberg — Mon, 30 Nov 2009 10:06:25 +0000

So I’ve decided to start a new project, to solve as many euler problems as possible from http://projecteuler.net/, in Python! The task in hand is not only to solve them but to think outside the box and add new features to the code which might become suitable in the future, who knows.

Let’s start off by solving the first problem!

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.
Find the sum of all the multiples of 3 or 5 below 1000

Now you might think it’s useless if you Only can solve this for 3 and 5, so why don’t we just make a tuple with the appropriet set of numbers?

My function declaration ended up looking like this

1	def sum_naturals(max, dividers=[3,5])

Where the variable max is, in this case, 1000. to test it out, I want the following to be true

1 2	# Prints 23 print sum_naturals(10)

This problem is not really rocket science so I’ll just let you guys look at the code and try to figure out what I was thinking, and please leave comments if you like or disslike it.

1
2
3
4
5
6
7
8
9
10
11
12

def sum_naturals(max, dividers=[3,5]):
result = 0

# Iterate through the numbers from 0 to max
for i in range(max):
# Iterate the dividers and divide i with each Divider
possibleDivision = 0
for divizor in dividers:
if (i % divizor) == 0 and possibleDivision == 0:
possibleDivision = 1
result += i
return result

This is actually a perfectly good example on “How to start python programming”. If requested or if i just feel like it, I might create a serie where I break these or similar problems into smaller pieces and explain them. Maybe I’ll throw in a couple of C#, C and PHP examples aswell. You decide.

Happy coding!

Testing the new Code-tag

Filip Ekberg — Mon, 30 Nov 2009 08:47:03 +0000

Testing testing…

1
2
3
4

// some code
$i = 1;
?>

Seems like it works?

Communication issues when adapting outsourcing

Filip Ekberg — Sun, 14 Dec 2008 17:19:46 +0000

Table of Contents

Communication issues when adapting outsourcing. 1

Background of Outsourcing. 3

A first view.. 3

Main benefits. 4

Adapting Outsourcing to your project 5

Handling work load over seas. 5

Communication problems. 5

Main problems. 5

Cultural problems. 6

Technical problems. 6

Outsourcing and Open source what makes them similar. 9

Open solutions, the advantage. 9

Marketing and new technology, community help. 10

References. 12

Background of Outsourcing

A first view

Let’s assume that you run a company, no matter if the company is big or small. Just imagine having to build a project where you know that your current staff either doesn’t have the right knowledge to solve this problem or the number of staff members is not sufficient. This is where your company will face a problem, either you hire some new personnel or you consider Outsourcing your project. In this text, we will talk only about outsourcing when it comes to information technology projects not any other work fields such as call centers etc.

So when browsing Wikipedia¹ we see that the following description is given “Outsourcing involves the transfer of the management and/or day-to-day execution of an entire business function to an external service provider”. This means that we can transfer our activities on our project to another country and have others take the work load. If we think closely on this, for how long has really outsourcing been available, when did it become easy to Communicate with countries far away? The answer is fairly easy, assume we had no internet and no computers, how would we then communicate with ie India? It would be impossible to this without our technology we have today. So considering a good interaction with computers is both a requirement and in today’s work spaces something that we can assume exists.

Outsourcing your project has in the last couple of years become a bigger and bigger way of solving company problems, these problems being Cultural, communicational and other areas of inconvenience as discussed by Sofie Alriksson².

This gives a good overview of what exactly Outsourcing is and how it’s adapted, now let’s continue discussing benefits and how technical problems might affect our work.

Main benefits

As roughly mentioned above the benefits of outsourcing in general is to take the work load of your staff or to gather new personnel. As mentioned by Sofie Alriksson², adapting Outsourcing is mainly because you want to work on your core activity and let others focus on the outmost parts of the project, having companies’ overseas working on your modules while you are focusing on the main frame.

When having a computer project the price today is often very high, especially the production const, personnel in ex Sweden is very high this will of course give a result that the project will either be rushed or that the company will not afford having the project running for long. By outsourcing your project this scenario might change dramatically meaning that the cost for personnel is much less and this giving more money to more personnel having the project released faster.

Adapting Outsourcing to your project

Handling work load over seas

One of the first things you might consider when starting a project is to have all the documentation ready, this means that having UML-documentation, project plans, time tables and other planning papers ready when outsourcing, because being over-prepared doesn’t exist in the world of outsourcing.

Another thing to consider is; how will the outsourced company handle regular deliveries? What project models do we need to follow? These are some key points to consider, which again takes us to the most important part of all, the computer interaction. We can’t have fairly good English speaking personnel overseas calling us in the middle of the night giving us a project status report. A lot of the countries where outsourcing is cheap, is in another time zone that where the staff is actually expensive.

So how would report on a daily basis work? E-mails might not be as secure as you’d like, because the service itself is not encrypted, meanwhile there are of course solutions for this, but not to take this too much off topic, I’d say that using a closed project platform such as Sharepoint or any other project organization software out there. You can probably find a lot on the open source community which you could customize for your needs.

However, let’s not talk more about the software to be used but rather how we use the selected way of reporting. This is something that we really need to point out to the outsourced company, how we want them to report. As mentioned before, being to clear on what you need, how you need it and when you need it, is never a bad thing.

Communication problems

Main problems

Outsourcing might sound very good and sure can be a good solution for your situation. However, there are always downsides with solution that presents them as being this perfect. These problems are taken up by both Sofie Alriksson² and Jeff Atwood³, besides from the obvious that your project might be shipped to India where you will have no visual perspective over the work, you might find troubles such as the ones Jeff Atwood³ states here “They get cancelled. Or the consultant who bid on the work never delivered, or delivered poor results. Or the client has unreasonable expectations, or doesn’t actually know what he wants.” What actually does happened if you bid too low and the consultant or outsourced company realizes this and in the middle of the process decides to quit? There’s no good solution for that problem, being repetitive is the best learning process, so here goes again, never ever give to little information.

Cultural problems

The above problems isn’t the only issues when adapting outsourcing, you might as well find that the cultural difference it way to big and this problem is clearly talked about in Sofie Alrikssons² paper, she also presents a possible solution which in this case was to inform the company where you outsource of your culture and how you like your work to be handled. It’s also very important that the hiring company has knowledge about the other culture, understanding is very important from both parties.

How does the cultural problem affect the computer interaction? For instance imagine outsourcing your project to India where they have totally different believes than we have here up north, this means that they might have different rituals than we do such as preying on a regular basis and on a specific time. If the hiring company does not have knowledge about this, what happens when we try to call them at this time, or when we assume to have something delivered? As you can see, this is not really a computer interaction problem, but rather a religious misunderstanding. But a cultural problem that actually will affect the interaction is the Technical perspective. Sweden per say is one of the countries in the world with the best technology, meaning that we might actually have different assumptions regarding technology and how we use computers, than the company in the outsourcing country. The reason for this might be a lot of different ones but for instance that the country is in general poor and can’t afford to take in new technology and adapt to the new standards. This is a very important point when viewing and discussing human computer interaction.

Technical problems

Some of the technical problems are talked about in the previous topic but there are another perspective than the “cultural technology perspective”, the upcoming issue is however a result of that problem. If you imagine the scenario where a company in Sweden needs a new application to be developed for the new mobile technology. If this was a couple of years ago, let’s say 2004 when 3G was fairly new in Sweden and the company 3 was the only ones having this. What if the company 3 would want to develop a new mobile application using the 3G technology, but the application is so advanced and needs a huge amount of staff members to complete. This is simply too expensive for a new company like this to invest in.

However outsourcing this will help and make it more cost effective. But outsourcing this to a country like India which might not yet have this technology, will cause an inconvenience. This problem will therefore make the project cost much more, since the customer needs to set up a test area and development area for this to be developed and from a strictly computer interaction perspective, who says that the people adapting this technology in India, will follow the same principles as we do here?

We need to keep in mind that different people think different and that different cultures are very different meaning; Applications created by an outsourced company might not be as you would’ve made it yourself. Keep in mind that we are talking about software and / or general computer development and research. With this in mind, how differently would you think that an outsourced company documents, programs and do other tasks differently from how you or your staff would?

This question brings up a huge problem when outsourcing, the technology and the way of adapting it, will cause issues between the parties and as Jeff Atwood³ said “For example, people asking for a clone of ebay for under $500”

A new company in Sweden that might not have any experience working with software development might think that it’s just typing as Jeff Atwood⁴talked about. But this is in fact wrong, it’s complicated being a software developer and having to do with a software project might not always be so easy. Thus the applications that developers, managers and other involved staff members use has a quality requirement, they need to be top notch. Using such software and styles might not be widely known, a company might have its own developed software which they do not care to share with other companies. These are also aspects to take in mind when taking on a project which needs outsourcing.

Having discussed the benefits of using outsourcing and the downsides with the applications, culture and other aspects, we need to take a look at a final point on the downside this being, the result of the software product. We can assume that people from ex India are smarter and have another mindset than other countries such as Sweden, they work for less, they know they can easily be replaced, which leads to a harder work style. Now what can possible have to do with Human Computer Interaction and the “samrtness” of a population? Having a usage base that is generally smarter and thinks on a completely different basis will result in your application being made for this crowd. This directly affects the computer interaction, on the visual basis that is, because the hired personnel might interpret how to solve something graphically in a way you would never imagine.

Outsourcing and Open source what makes them similar

Open solutions, the advantage

Open Source is a very broad topic and will not be discussed thoroughly here. But the main purpose of an open application is that the community, being either developers or users can easily get the software and / or its source code; Source code being the logic for how everything behaves.

You could say that all software projects share a specific way of working and this is mainly the structure and documentation of the project. Some projects require this more than others; such as an open source project and an outsourced project. An open source application is often free of use, but there are of course applications that do cost money but are still open source. Either way, the most important part is to help the contributors understanding your business logic and the graphical user interface programming.

This is done by having good documentation and well commented code where you explain all the steps, of course you should never make code unreadable by adding to much comments, then the interaction with the code will just back draft.

When you create an open source project, you force this structured work way from the beginning, there’s no space for spaghetti code or ugly solutions. These parts will be replaced immediately and the programmer will probably not be welcome on this project further on.

This is a big advantage, letting the community contribute to your project and giving you a lot of feedback on it. However, what happens when you want to go global and have a paid for application? The contributors will then require some kind of assets for their work.

The feedback from the community is worth very much on a big project and might help you in long terms; the community is often willing to help out with the most outrageous projects just for fun or for experience. On an outsourced project however, you might not feel that you have the same commitment, however this is because you actually pay for something getting done, and you need to rely on the programmers to do their work. In an open source development you can’t force anyone to do your work.

Marketing and new technology, community help

Let’s play out the scenario where you somehow come up with an idea of a technology or a software that isn’t on the market, but you know that this will help the community a lot in many ways. A project of this sort might be an electric car or a car driven on water, however that has nothing to do with software projects so let’s not talk more about cars.

When you have this kind of idea you either want to make a lot of money or you want to help the public community, but who ever says that money isn’t equal to motivation lies. The main purpose of a project is, in most cases, about making money. So you stand before a dilemma, either you publish your diagrams, project description and other project plans on a public community forum or create a website where you explain your situation. Which then might actually lead to someone else stealing your ideas and benefiting from this which results in them being rich and you being back to square one.

But planning the project well and having good license agreements can help you on the way, you might state that if anyone works on the project they are entitled to their name being written in the EULA or somewhat like that. Keep in mind that an open source project might not be a completely usable alternative for an outsourcing solution but it’s a good point to take when we talk about computer interaction because both type of work requires some common work ways which are good to think about.

Having an open source project which grows big might not only help you development wise but also marketing wise, because having a lot of programmers sharing their thoughts and interface suggestions and so forth will attract a crowd.

And think about it, when having an outsourced project you need to have the following aspects top notch:

· Project plan

· Commenting templates

· Documentation templates

· Wiki

· Forums

· Bug reporting system

· Source control system

These are just the aspects that really need to be perfectly planned no matter if it’s an open source project and outsource project or a local project on your company. For human computer interaction purposes these need to be top of the line.

Can you yet see another similarity between open source and outsourcing? If not, let’s present it; People around the world contributing to software development. See that as a headline of both Open Source and Outsourcing and the two latter names as an “implementation” of this expression. When having an open source project you never know what culture a contributor comes from or which time it is in his country. This forces an adaptation to new technology and a generic culture understanding.

References

1. Wikipedia. Outsourcing. Wikipedia. [Online] 12 08, 2008. [Cited: 12 08, 2008.] http://en.wikipedia.org/wiki/Outsourcing.

2. Alriksson, Sofie. Communication problems by using outsourcing international . Communication problems by using outsourcing international . Halmstad, Halmstad, Sweden : Halmstad Högskola, 12 08, 2008.

3. Atwood, Jeff. Coding Horror. Can You Really Rent a Coder? [Online] 11 23, 2008. [Cited: 12 10, 2008.] http://www.codinghorror.com/blog/archives/001190.html.

4. —. Coding Horror. We Are Typists First, Programmers Second. [Online] 11 17, 2008. [Cited: 12 10, 2008.] http://www.codinghorror.com/blog/archives/001188.html.

5. David Axlund, VD Mailopages Sweden AB. VD. Karlskrona, 11 20, 2008.

6. Ekberg, Filip. The Art of Teaching. 05 : 12, 2008.

7. Masses, Development for the. Development for the Masses. Communication problems in outsourcing. [Online] 2008. [Cited: 12 10, 2008.] http://www.dev4masses.com/a_communication_problems/.

By Filip Ekberg and Göran Petersson

The Art of Teaching

Filip Ekberg — Fri, 05 Dec 2008 12:33:45 +0000

The Art of Teaching

Filip Ekberg
filip.ekberg@bth.se

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?

1. 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?

2. 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.

3. 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.

3.1. 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.

3.2. 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.

3.3. 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.

4. 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.

5. 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 co-worker 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?

6. 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.

7. 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 co-workers and students inspiration on a regular basis might in fact help the persons succeed and somehow indirect force them to teach themselves.

8. 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 [3] 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.

9. References

[1] David Axlund, VD Mailopages Sweden AB – There might not be any direct references in the text or quotes from David but he has given me a lot of inspiration when it comes to management and giving people knowledge.

[2] Filip Ekberg – I have myself in this text as a reference because a major part of it is from own life experience .

[3] www.google.com http://www.google.se/search?hl=sv&q=define%3A+open+source&meta= 2008-12-05 – Definition of Open Source

Polymorphism – A Practical Example

Filip Ekberg — Thu, 13 Nov 2008 17:01:38 +0000

Classes, inheritance and polymorphism can sometimes be somewhat hard to understand. So a practial example suits many well. Therefore this will be a tutorial where i will touch the areas of classes, pointers, inheritance and polymorphism.

So to just clearify some expressions i will add a little dictionary at the top:

Class
A class can somewhat be seen as a blueprint of your object. I.e. having a blueprint for a building, then this would be the class. Then a Constructor would build this to become an actuall touchable object.

Inheritance
When you inherit something you can think of it more like you extend this thing. I.e. having a Car and then having a Sports Car where there are some new variables to it. The Sports Car is actually a Car but it’s also extended with new properties.

Polymorphism
This is taken from Wikipedia: “In simple terms, polymorphism is the ability of one type, A, to appear as and be used like another type, B. In strongly typed languages, this usually means that type A somehow derives from type B, or type A implements an interface that represents type B”. Read more here

Pointer
For a pointer explenation look here

I will be using Visual Studio 2008 with the built in C++ compiler for the following examples.

A good practice will be to create a Bank, when you get a new assignment or just want to create something new, start by thinking about the structure, what actuall needs does this have? Well when creating a Bank i think to myself that i’d like to be able to create Bank Accounts, attatch these to People and you can go on and on.

But, for the example i will only go as far as creating a Bank, a Bank Account ( Abstract ) and a Student Bank account which is the only Bank account you can actually get.

So creating a simple diagram over the project, i got something like this: So now we have a Bank, Account and Student Account, what kind of variables do we need?

Bank
Bank Name
Accounts

Account
Balance
Interest
Max Loan
Account Holder

Student Account
Amount of Deposits
Last Deposite Month

So the big difference between Account and Student Account is that the Student Account have different rules than Account and therefore calculate a lot of things differently. We won’t go through all the logics. There will of course be a window for you to evolve this application as you feel nessesary.

Now when we have a defined structure we can start by creating a new Project and it’s files. My project will be called Bank and the following files will be placed in it:

main.cpp
Bank.h
Bank.cpp
BankAccount.h
BankAccount.cpp
StudentAccount.h
StudentAccount.cpp

When all my files are created a start by definint my program entry point, this being my main. Notice that i will be posting code snippets as pictures, because you should Write this yourself and not copy my code!

We prepare for an input/output stream by including and setting using namespace std;

Now the next part is to define the Bank.h We need an appropriet constructor, desctructor and some access methods, remember to never open up member variables publicly!

The #ifndef part is important for the compiler, we dont want to define our header file more than once, because that is not nessesary!

I assume all the parts are clear except the last one, read more about how that pointer type works in the previous post here on my wordpress.

The implementation itself will be up to you, i will only be showing the structure, header-files and some code from main and where polymorphism is concerned!

The next file to create would be the BankAccount, remember to add #include “BankAccount.h” to Bank.h when it has been done. Otherwise the BankAccount *accounts array will fail because undefined symbol.

Back to the third file, the BankAccount.h this is how i would structure it:

The part to look deeply on here is the Deposite method, watch closely, it’s defined as followed: virtual void Deposite(double amount) = 0; So this method is expected to be overrided in a inherited class and it has the return type of void and an in parameter of the type double.

Now the next file to create is the StudentAccount.h where we will be deriving from BankAccount.

So the following class StudentAccount is extending a class called BankAccount. So this means that StudentAccount is a BankAccount with extended properties and/or overrided functions.

Now, look closely again, here we have the virtual void Deposite part again, but without the =0, so this means we will be creating a definition for this function.

Also the Amount of Deposits and Last Deposit Month is just there to simulate some properties that might be nessesary to do something on a student accont. In my case this is for the Deposite. A Student Can’t deposite money more than three times per month, this is because a student gets 2% interest everytime they deposite money.

This is my Constructor for StudentAccount

As you can see, we pass the Variables Owner and Deposite back to the constructor of the base type, being BankAccount.

Now this is how my Deposite Method is implemented:

Now the last think i want you to look at, is my final Main:

dth="450" border="0" />

I want you to try and create all the nessesary functions in Bank.cpp, BankAccount.cpp and in StudentAccount.ccp to get the following output from this Main.cpp:

‘

I would happily answer any questions about this project. A link to the complete source code is here

Pointers & Double Pointers

Filip Ekberg — Tue, 11 Nov 2008 19:50:18 +0000

Definitions
First off, we need to clearify what a some of the expressions i will use mean. These are the following expressions:

Stack
Assuming that you know about a computer having RAM ( Random Access Memory ) which allows you to store information and have this accessable faster than you would on a secondary memory like a harddrive and/or cd-rom.

When a program is executed there is a part in the memory reserved for this application to use, this “space” is called the Stack; The stack is always the same size and it’s not possible to change it’s size on any way.

Heap
The Heap is also a “space” on your memory, actually it’s all the memory not allocated as a stack. So when your stack is defined, everything else can be expressed as the Heap.

Pointers
What is a pointer really? A pointer is a globally used expression to reference that your somewhat “point” to something. See the following illustration

On this image we have something that we point to, let’s call A our Object. So having A as the actualy object, play with the thought that B and C isnt there, and there are no pointers to it.

This would infact mean that we had A allocated on the Stack. When does this become a problem? So play with the thought you have a really big information base such as a User Layer where you store a lot of data on each user. Then havnig a big register on all the people attending a course would take up somewhat a bigger space than we have free.

When is is an issue, we can use a pointer, to reference to this object. You can of course point to an object that you have on the stack, but that’s not. afaik, what it’s initially intended for.

So we tell our program that we want to create a Pointer, this pointer will in fact be stored on the stack, but a pointer only takes up 4 bytes so this wont be a problem.

After creating the pointer, we create the object itself and have the pointer B point to this.

Pointer, Objects s & Arrays
Assuming you know about some object orientation and how an object is constructed i will not go in to this very deeply. I.e. we have a class called Person and we want to create somewhat a register over students attending a course, what we initially want to do is create an object array, where we can store all our persons, using c++, as i will do in the following examples you would write something like this:

1	Person *attendingStudents = new Person[size];

Where size is equal to the max amount of students.

Running this code, the constructor of Person will be runned as many times as the size of the array attendingStudents. How is this a problem? This becomes a problem when we dont want to run the default constructor and allocate the object size as many times as the total array size, this has too much overhead.

First of all, how does this look in memory?

On adress 0 to adress 3 wnicn means 4 bytes; every memoy block is 4 bytes; the pointer attendingStudents is allocated and on that area a 4 byte long adress is stored which in our case is 84. The size of the given Person object is not given but just play with the thought that its 4 bytes and the size is 10 this would mean the total size of the Person array would be 10 * 4 = 40 Bytes going from the address 84 to 124.

However, let’s say that the Person object takes up 4 times as much so it takes up 16 bytes per Person object, this would result in 16 * 10 = 160 bytes, going from address 84 to 244. Now, there is a big overhead if we dont use all the persons and it would be stupid to call the constructors twice.

So, how about, we just point to something that we know is a pointer, and then let this poitner take care of the rest? But we just initialize the first step?

Double pointers
Thjis is were double pointers comes in handy, look at the following code:

1	Person *attedningStudents = new Person[size]:

This code is not as straight forward to look at, as the pervious one, but it basically means,

1	Person **attendingStudents

= Create a reference, to a pointer, what is a pointer? A pointer is something that will in the end point to a data type, so what we do here is saying that Point to a Pointer, this pointer will eventually have the data type Person.

Just to clearify, a pointer to an array, initially points to the first index in that array. So after creating the Pointer to a Pointer we tell it to point to a new list of Pointers, the amount of pointers to create is the same as the digit in size.

This might not make any sense, but take a look at the following

Initally these pointers don’t point to anything at all so what we can do is: attendingStudents[i] which will take us to the adress 84 and then create an object on this index by doing this:

1	attendingStudents[i] = new Person();

Why is this method better than the one before? Well this assures that we Only have the 11 pointers which takes 4 bytes per pointer. 1 pointer on the stack, referencing 10 pointers on the stack. When does this give us overhead? This gives us a 4 byte overhead when we start creating our Persons. But the execution time saved and just given 4 bytes ovearhead per pointer, this is a preffered method by me.

Importance of good Architecture, Structure and Patterns

Filip Ekberg — Fri, 22 Aug 2008 21:54:08 +0000

Often when developing software such as websites, windows ( or any other operative system for that matter ) programs, the begining of the progress is quite simple; you have your ideas and may have some thoughts about how to implement everything. But what often is forgot when developing software is the importance of thinking ahead, thus, planning for a larger software that you have in mind.

For an example, when i started developing SmartIT Invoice i thought of it as a software that would generally help me organize my small amount of invoices. But as the years pass my company grows bigger and bigger and once im up to n-numbers of invoices, a simple List View won’t be sufficient. Therefore after implementing my Invoice software, i started thinking about how i could change everything and structure the code for helping me in the future. I had in mind that i might not always want to use the Windows Graphical Interface for input and output so as i always do, i seperate the Design code from the Logical Code. This meaning that my application has three layers. Them being:

Application Layer, code for display, handling window events
Logic data layer, database connections, objects
Data layer, this being the database with functions, views and procedures

By having these three layers i can easily change one of the layers without changing the next. Of course this is not entierly true, i would have to change some parts in the Logic Data Layer if i changed the DBMS. I would however not have to change that much if i just changed the behaviour of a Stored procedure.

Again takng my Invoice softwre as an example, i recently released a software called Webexpress.nu which allows customers to create their own website and for this i need somewhat of a payment system. Of course using Credit card payments is nice and easy but not entierly nessesary. So by just adapting my Webste to the current Logic Data Layer of my SmartIT Invoice software, i could easily get an intergration that allowed me to create customer invoices that pops up on the user account, when they are online on the page of course and even directly to my software, withouth any adjustments in the Data Layer or in my Windows Software.

This proves the point that well structured code and seperate layers will help you along the way of program development.

As a side note the Data Layer in this case is a Windows DLL with .NET 3.5 code which makes it even easier to implement when the website itself is asp.net with .net 3.5.

There are a lot of good design guidelines out there which will help you structure your software better and help you understand how to always follow a pattern. A pattern doesn’t, in my point of view, have to be a pattern like Singelton etc, it can by any means be a way for yourself to regocnize your own code, thus following a pattern. Example, i often tend to use m_ before member variables and write all functions and access methods with a capital letter.

Have fun programming!

Big O-notation

Filip Ekberg — Mon, 18 Aug 2008 21:55:00 +0000

So starting school in a couple of weeks and being told that you wont get any “allowance” from the state makes you think twice about your current situtation. Not that this has anything ( directly ) to do with o-notation. However this is how i forced myself into learning it. I have to re-take an exam in Algorithms and Datastructures this upcoming week and i want to share my experience in big o-notation.

So basicly we have an array, a list of some sort and somehow we need to go through each element in this list. Having ‘n’ elements we need to create some kind of look like this:

1
2
3
4
5
6
7

void walkList(int[] numbers)
{
for ( int i = 0 ; i < numbers.lenght(); i ++ )
{
print numbers[i];
}
}

Now this will print all the elements contained in the list of numbers. Lets look at this from a time complexity way, 4 constant operations these being:

function input
int i assignment
i < numbers check
increment

And the loop will run ‘n’ times meaning we have n + 4 this will give us O(n + 4), but constant access times are irrelevant talking about runtime so all we do is write O(n). O, ordor as it is pronounced, is a way of stating the time complexity.

Now lets say we need to process ths array in another way, play with the thought that we have this list of numbers and for each number we want to go through the list again. This would give us a nested loop and give the time complexity O(n^2). This meaning that we need to process the list twice for each item, hence n ^ 2.

Looking at a sorting algorithm like Merge Sort that first divides the list into 2 peices untill its at the last item, then merges them. We see the typical behavior of a log() with the base 2. So, the split / sort part is basicly log(n) while the merging part is n and log (n) * n = nlog(n) which is slower than log(n). There are however no “standard” sort algorithms that can do better than nlog(n), in a random case that is. Best case for i.e. bubblesort is log(n) and worst case for bubblesort is log(n^2) which is slower than mergesort.

Mergesort

When is time complexity nessesary? I would say that during all my years of programming, learning speed, size and other performance parts the hard way, i would say that this is a very good complement to fast calculate time complexity of your algorithm. You can be a very good programmer without knowing a lot about this. A lot of this is just something that a programmer knows how to handle without knowing O-notation. But as said, a good complement.

Objects, Objects, Objects!

Filip Ekberg — Fri, 08 Aug 2008 19:55:36 +0000

By looking on everything in life as Objects is one of the benefits from doing object oriented programming. It doesn’t really matter if you master the technique or if you are in the beginners stage, just starting with object oriented programming will open up your eyes.

Seeing how objects change your perspective on both programming and other stuff in life, i’ve notied that when i wanted to learn something like animating in Flash, knowing object orientation helps. Not particulary with the animating, but with the thoughts on how i will structure my animations.

I.e. that i have to create a move, where a part in this move occures many times, repeatinly creating this scenes and moving them around is a fairly harsh work. Looking at it from an object oriented perspective you see that you have:
A main film
An object containging the scene

When needed, you just insert a new object of the scene and you never need to repeate the procedure of creating the scene.

Using Objects isn’t always good though, when you need to store the memory on other medias than the RAM you need it to be serialized, which is not handled to good by some languages such as PHP.

The basics of object orientation is easy to learn over a few minutes, when you try to look at everthing at a new perspective, the learning period will decrease.

Let’s say that you have a Car, this car has 4 wheels, 5 doors, 6 windows and so on. The doors got handles, the wheels got air in them and so on. Seeing all these parts as Objects is a good way to play with the thoughts of object orientation. See how i apply inheritage on a car:

1
2
3
4
5
6
7
8
9
10

abstract class BasePart
{
    int m_ModelNr;
    string m_Name;
    public BasePart(int ModelNumber, string Name)
    {
         m_ModelNr = ModelNumber;
         m_Name = Name;
    }
}

Everytime you create something, the created part / object or wathever got a Model Number and a Name, just look at carparts or a coka cola bottle.

1
2
3
4
5
6
7
8
9
10
11

class Door : BasePart
{
    int m_DoorType;
    int m_Weight;
    int m_Code;

    public Door(int DoorType, int Weight, int Code, int ModelNumber, int Name) : base(ModelNumber, Name)
    {
     ///.....
    }
}

The codesnippet above shows the basics in object orientation, this is a Base Class which is Abstract, which means that you cannot create an object of it.
The Door is derived from a BasePart because its a BasePart.