blog.GOEran.no

Reinstalling Windows Home Server system disk!

Gøran Hansen — Tue, 21 Jul 2009 19:29:17 GMT

About a year ago I assembled a WHS (Windows Home Server) from old computer parts I had lying around – finally I could put them to use. I added the following hard drives:

200 GB SATA (for the system)
200 GB SATA (data)
200 GB SATA (data)
400 GB SATA (data)
320 GB USB (data)

I can’t remember why I decided to use the smallest disk for the system, but it was a mistake. There are some good reasons to choose a larger disk:

Size of the system disk limits the file size when transferring files to the server. WHS splits the system disk into two partitions: C:\ (20 GB) and D:\ (remainder of the disk is used for data). When you transfers files to a WHS the files will land on the D:\ drive before Drive Extender moves them to secondary disks in the storage pool. So if you have 40GB disk for system, you’ll have 20GB available for data. This limits you to only transfer files less than 20GB, which is small in the year of 2009 when HD videos are common. I discovered this limitation while trying to move a 120 GB virtual hard drive file to the WHS for backup – not fun at all
When your amount of data grows, you need to swap out the disks in the storage pool. When I have replaced the 200 and 400 GB disks with brand new +1 TB disks, I’m still left with a 200GB system disk when I could had a 1 TB system disk – argh!

So instead of making the same mistake as I did, install the system on a large disk! I can recommend a +1 TB disk.

Using a small disk for the system was a bad design decision by me. This forced me to replace the system disk with a 1 TB disk. I started on this “little” project this weekend, and ended up spending lots of hours on it. As usual, before jumping into conclusions, I did some research, and luckily enough I found a good post on the WHS forums over at Microsoft’s.

The cool thing about WHS is that it’s designed to take care of your data. It’s by design enabled to handle a crash on the system disk. If your system disk crashes, you can just replace the disk with a new one and reinstall the system. During the installation process, it will discover your other disks from the storage pool, and based on them it will be able to recover all your data. You’ll have to use the “Server Reinstallation” option while installing WHS.

The process

Buy a new disk – I bought a 1 TB disk
Shutdown the system
Replace the old drive with the new one
Boot up the system from the WHS DVD
Choose the “Server Reinstallation” option
The Drive Extender rebuilds your data from the storage pool
Create user accounts, install add ins etc.

Read the forum post in detail, and notice the caveats; when doing this you lose the backup database, installed add ins etc.

While doing research I also checked if people had experience with replacing the system disk using imaging tools like Norton Ghost and Acronis True Image. There seemed to be mixed results out there, and it’s not supported by WHS.

And before you go assembling your own WHS I recommend that you go read the white papers!

Here are some other WHS resources:

Happy hacking!

A Software Craftsman’s 200$ Bookshelf Upgrade!

Gøran Hansen — Thu, 28 May 2009 10:50:18 GMT

About three weeks ago, I asked my readers and some people in the Norwegian developer community about what books they have in their bookshelf. The response was good, and I ended up with many good book recommendations.

Today I placed a new order on Amazon, and spent 200$ to upgrade my bookshelf. If you read further, you’ll see which books I ordered.

Software Craftsmanship: The New Imperative
Pete McBreen

“This book is the foundation of the Craftsmanship movement that seem to get momentum these days (and that is a good thing). “Software craftsmanship” sounds nice and has a positive ring to it, so it does not seem to be hard to endorse. But for Pete McBreen software craftsmanship is more than just taking your job serious. It’s a way to organize teams, a way to run projects, a way to run the whole industry, a way to organize learning, and a new way to look at developers. I really like many of his ideas, and I hope people like the Craftsmanship movement not just because it sounds nice, but because they know what this book is about. Read it and see what you think of “Software engineering” when you’re done.” – Tore Vestues

Working Effectively with Legacy Code
Michael C. Feathers

“Don’t be scared away just because the title has the word “legacy” in it. This book is not about VB6 or Fortran. Not at all! It’s probably the best book I’ve read about writing automated tests. It is about how to work with code that is not tested (which is Feathers definition of legacy code). And it is about testing in general. If you want to write tests for code that is not previously tested (or written in a way that makes it testable), this book is for you.” – Tore Vestues

Test Driven Development: By Example
Kent Beck
Kent Beck is the man behind design patterns and TDD. Do I need to say more? If you don’t know his work, have a look at his presentation from RailsConf 08.

Extreme Programming Explained: Embrace Change
Kenth Beck

“Extreme programming is beautiful. Not only because it uses the well known practices of TDD, CI, Pair programming and so on. Xp is beautiful because it understands that practices do not stand on its own. You need a mindset. The mindset is expressed through the Xp Values, and throughout the entire book. Xp is close to a philosophy. Read the book and I’m sure you will see software development in a slightly different way.” – Tore Vestues

Agile Software Development
Alistair Cockburn
Twitter sphere is amazing. I got this recommendation from my online friend Liam.

Here is a review from Amazon:

“Every fifteen years or so, a great book pops up that describes what projects are really like. There was Brooks, then DeMarco and Lister, and now there’s Cockburn.

Why is there such a gap between these great books? Possibly because the message they contain isn’t the easy-to-digest dictate: “run your project this way and everything will be fine.” Instead these books all focus on the fundamentals of projects: people and the way they work together. These books treat people as people, and not replaceable parts in a process. The books accept people’s foibles and inconsistencies, and work out how to work with them, rather than how to try to stamp them out. The books ask: how can we help these funky people work better together to produce great software?

Agile Software Development has some great answers, which makes it a significant book. It deals with the issue that programming is essentially communicating. It looks at the success factors of individuals, and how to help align the project with these. It discusses practical ways to reduce the latency of communication (do you know how much each extra minute taken finding things out costs on a 12 person project? How do you line your walls with information radiators?) The book mines the metaphor of development as a cooperative team game, and looks at development organizations as a community, where good citizenship pays.” – Dave Thomas

I want to thank all of you how responded to my post, and my twittering. If you wondering; the total cost of the books was 160$, and 40$ in shipment L

Capgemini Norway’s technology blog is online!

Gøran Hansen — Wed, 13 May 2009 13:53:49 GMT

My employer, Capgemini, just released a Norwegian technology blog. We have been working on this project for a while and have finally released it! Puh!

My first post on this blog was about technical debt. I was so inspired by Ward Cunningham’s metaphor that I just had to write about it. Anyway, the content of the blog is in Norwegian. If you are a non-Norwegian reader, it’s probably not in your area of interest.

Feel free to visit our blog and follow us on twitter.

UncleBob’s keynote from RailsConf2009 – the most inspiring talk I’ve ever heard!

Gøran Hansen — Tue, 12 May 2009 20:29:38 GMT

If you are a software developer and consider yourself as a professional, you should watch this presentation. Robert C. Martin aka UncleBob has been a programmer for 40 years, written tons of articles and some really good books. He has worked very hard to promote professionalism and craftsmanship to software developers. In this keynote you’ll see him talk about that. Watch and learn!

Click to play
Click to goto source

Thanks to UncleBob for giving us such a great presentation. And thanks to Fredrik for pointing out this video for me.

A Software Craftsman’s Bookshelf

Gøran Hansen — Tue, 05 May 2009 18:58:33 GMT

Every now and then I get the question about what books I recommend on the topic of programming and software development. As I try to practice the DRY (Don‘t repeat yourself) principle while writing code, I‘ll also intend to do it in real life. And by answering this question in form of a blog post, I‘ll be able to redirect future questioners here.

I’ve assembled a list of books that I’ve read or that’s in my books-to-read queue.

The list

The list is sorted by my favorite books.

Clean Code
Robert C. Martin, also known as Uncle Bob
I finished reading this book a week ago and I have only one thing to say, it’s a masterpiece. If you are a professional programmer, you should read this book. I learned many, many neat tricks reading this book. Uncle Bob have 40 years of experience as a programmer, and he worked very hard not to become a business wonk, and this made him sharp like a knife. Read this book, it will give you a clear perspective on how to write quality code. Expect to read lots of code samples, and work hard to grasp the content. I’m going to convince every programmer I work with to read this book!

The Pragmatic Programmer
Andy Hunt and Dave Thomas
Hunt and Thomas are great storytellers and you’ll be blown away with their wisdom – it seems like they have been programmers forever! I like this book because it‘s hands-on and lots of the advice you get by reading it, you can put into practice in your daily job. The book tells you everything you need to know in order to become a good programmer.

They also push hard that programming is not only science, but a craft, and you need to practice it a lot in order to become a master - hence the slogan “From journeyman to master”. The book will provide you with tons of practical tips and the first one is “Care about your craft”. If I ever get responsible for a team of developers - hey, who the heck would put me in charge? :p, I’ll give this book to every one of them and then send them home and ask them not to come back before they have completed the book!

Design Patterns: Elements of Reusable Obect-Oriented Software
Eric Gamma, Richard Helm. Raplh Johnson, John M. Vlissides AKA. The Gang of Four
The first book ever to write about design patterns, it was released back in 1994 and it documented 23 patterns. I have to admit that I had to read this book several times to grasp most of the ideas, but it was worthwhile.

This book is not for beginners, but for developers with experience from OO (Object Oriented) languages and design. You probably find people argue that this book is not applicable today because the patterns were discovered in the time of C++, which don‘t contain modern language features like Generics and Events like we have in C# today. I disagree with these people because the core underlying principles are just plain old Object Orientation, but I can understand the argument. The samples in this book might not be as relevant for C# as they are for C++, and if you apply some of these patterns in a modern language, you obviously need to think about the features you have available in the language, and use them. There is a reason that we have the event language feature in C# today – so it’s easier to implement the observer pattern! If you learn and understand the observer, you‘ll also learn that loosely coupled code is harder to read and debug. The book is a good reference and contains the most general patterns you need to know about, but remember that even though you use a language with built-in language feature for some of these patterns, you should know about the pros and cons in order to make good design decisions! This is a good educational book.

Domain-Driven Design: Tackling Complexity in the Heart of Software
Eric Evans
I think this one is about to become one of the most important books out there on the topic of OO design and modeling. It‘s been a while since Evans published this book, but it seems to get more and more attention nowadays, and more and more people I talk to practice DDD (Domain Driven Design). I think the most important thing Evans teaches us is what he calls the ubiquitous language. The books also teach good modeling practices, and documents lots of useful patterns. This book made me revisit Object Orientation. You should read it, if you are experienced with OO design and programming.

Head First: Design Patterns
Elisabeth Freeman, Eric Freeman, Bert Bates, Kathy Sierra
This is the design patterns ABC-book. The authors have a great talent in communicating complex ideas in a way that‘s easy for the readers to understand. The book contains some of the same patterns as the GoF-book and the code samples are mostly in Java as well. Highly recommended for beginners on the topic of design patterns!

Windows Presentation Foundation Unleashed
Adam Nathan
The only book I‘ve read about Windows Presentation Foundation, and It gives a solid introduction to the technology. I admit that I haven’t read the book from chapter to chapter, but use it frequently as a reference when I need to learn new neat features about WPF. The code samples in the book even have color highlighting! This book should be in every WPF/Silverlight developer’s bookshelf.

The best Software Writing
Joel Spolsky
Mr. Spolsky has assembled a very entertaining book of essays on the topic of software engineering. The essays I remember are Paul Graham’s “Great Hackers” and Eric Lippert’s “How many Microsoft Employees Does It Take to Change a Lightbulb?”.

Agile Software Development, Principles, Patterns, and Practices
Robert C. Martin
I’m hooked on Uncle Bob, he is the Master Chief of programmers, and an awesome writer. This is a book I’ll read very soon.

Patterns of Enterprise Application Architecture
Martin Fowler
This book is yet another book that’s on my books-to-read queue. Fowler is a notorious craftsman in the art of software engineering, and I’m looking forward to take a snapshot of his brain!

Code Complete: A Practical Handbook of Software Construction
Steve McConnel
Have not had the chance to read this book yet, but I will sometimes soon. The word on the street says that this book is even better than Pragmatic Programmer – now we have to see about that!

Applying Domain-Driven Design and Patterns: With Examples in C# and .NET
Jimmy Nilsson
I haven’t had the opportunity to read this book yet, but people that have read it says it’s a more hands-on and practical book than Events book.

This is my list, for now, but I’m continuously seeking more knowledge in order to become a master in the craftsmanship of software development. While assembling the list I just realized that I don’t have a book about Test Driven Development – I should do something about that.

It would be interesting to hear what you and other fellow developers are reading, and what you have in your bookshelf – so therefore I‘ll start yet another meme and I invite you and the following people to answer:

Jonas Follesø – Silverlight guru, vivid speaker, long time partner in crime and friend!
Tore Vestues – wise guy and friend. I think of him as one of the most skilled craftsmen I personally know (It seems like Tore already had a book list, I’ve updated the link)
Anders Norås – Admirable and skilled software craftsman
Einar Ingebrigtsen – The Norwegian Scott Hanselman!
Mark Nijhof – Seriously skilled software craftsman and a community hero
Håvard Stranden – Fellow member of NNUG in Trondheim, active blogger and speaker
Børge Hansen – Active blogger and architect working for Microsoft Norway
Sondre Bjellås – Friend, thinker, mr. Robotics and the Norwegian Geek of the Year 2008
Fredik Kalseth – Highly active blogger about .NET, design patterns, testing etc. and a skilled software craftsman
Lars Wilhelmsen – Highly active in the Microsoft community and the new master chief of the Norwegian .NET User Group. Lars has now responded to this post. Click the link to watch his bookshelf
Joar Øyen – Friend, MVP and master chief of NNUG Trondheim
Pål Fossmo – Friend, MVP, good speaker and a skilled software craftsman. Pål has responded to this post
Kjetil Klaussen – Friend, good speaker and a skilled software craftsman
Johannes Brodwall – Norwegian agile guru!

Speaking at agile seminar tomorrow!

Gøran Hansen — Sun, 03 May 2009 14:56:55 GMT

Tomorrow I’m going to give a talk at Smidig utvikling Trondheim 2009, which is a seminar about agile. I’m really looking forward to this seminar because of good content and good speakers. There are some big names keynote speakers as well.

I’m not going to spoil too much of my talk, but I can say I’m going to talk about how teams developing software can be able to work in parallel if they apply loose coupling.

The best way to learn new API’s; TDD!

Gøran Hansen — Sat, 02 May 2009 13:23:16 GMT

In this post I will tell you a story about how I used TDD (Test Driven Development) to learn new a new API, and how I successfully managed to accomplish my task before expected, and delivered 100% working code (no defects), even though I did something I’ve never done before – interested? I thought so ;)

In the project I’m currently working on, I was given the task to implement a web service that integrated with a directory service using the LDAP protocol. This was something I’ve never done so far in my career, so I thought it as a fun challenge. The task was simple; I had to implement CRUD (create, read and delete) behaviors to manipulate entries in the directory. My main concern and the obvious show stopper were to figure out how to integrate with the directory service using the LDAP protocol.

As always, before I jump into conclusions, I sat down and started to think about how to solve this task. I had a gut feeling that told me I’ve read about this somewhere, about what’s the best way to learn new API’s. And after while it suddenly came to my mind! – It’s called learning tests.

“Jim Newkirk reported on a project in which Learning Tests were routinely written. When new releases of the package arrived, first the tests were run (and fixed, if necessary.) If the tests didn’t run, there was no sense running the application because it certainly wouldn’t run. Once the tests ran, the application ran every time.” – Kent Beck, Test-Driven development by example

Since I can’t reveal more about my work, I’m going to use another example in this story. I decided it would be fun to learn how to integrate with Twitter using their API’s and C#. Since integrating with Twitter is completely new for me, the situation will be analogues to the one I had solving the LDAP integration task for the customer.

Again, before jumping into conclusion, I started out doing some research, and ended up on Twitter’s APIWiki. The WIKI contained lots of good information and after a few minutes I learned that their API’s is built upon the HTTP protocol and that its REST based. In the WIKI they had listed up 3^rd party libraries for several different platforms, and I found a few for .NET, and decided to use an Open Source library called Twitterizer. My rationale for using a library was if the library is good, it would be easier for me to produce working code, and I’ll probably do it faster than using the built-in HTTP libraries in the .NET framework.

If you going to create a Twitter client or another type of application that integrates with Twitter, you probably have to figure out how to;

Authenticate and logon to Twitter
Update status
Get status from friends
Get list of followers

Learn to use the library

If you are used to TDD, you start out writing tests before any production code. You are probably also familiar with Uncle Bob’s Three Laws of TDD;

You are not allowed to write any production code unless it is to make a failing unit test pass.
You are not allowed to write any more of a unit test than is sufficient to fail; and compilation failures are failures.
You are not allowed to write any more production code than is sufficient to pass the one failing unit test.

When writing code, I like to work like this, so I started out writing failing tests to document what I had to learn in order to integrate with Twitter. The first, and the obvious test, was to figure out how to authenticate with Twitter. I also added three more failing tests; update status, get friends status and get followers. Here is what I ended up with;


               1: [Test]
            
               2:
              public
              void Authenticate()
            
               3: {
            
               4: }
            
               5:  
            
               6: [Test]
            
               7:
              public
              void Get_status_from_friends()
            
               8: {
            
               9: }
            
               10:  
            
               11: [Test]
            
               12:
              public
              void Get_followers()
            
               13: {
            
               14: }
            
               15:  
            
               16: [Test]
            
               17:
              public
              void Update_status()
            
               18: {
            
               19: }

I know, I broke Uncle Bob’s law 2 by writing four tests before any production code, but I’m pragmatic, my goal was to solve my task, not follow the laws like a slave. The positive outcome from breaking law was that I now had decomposed the Twitter integration task, into four more fine granulated tasks. I considered this my to-do list.

The next obvious step was to learn the Twitterizer API, which I did by using the Object Browser in Visual Studio. After fiddling around for a while, I was ready to start solving the first task; how to authenticate a user in order to logon to Twitter. I tested this by login to Twitter, and call the API for receiving status from friends. If the test received status from friends, I could assume the login was successful. After this test passed, the rest was a walk in the park, and here is what I ended up with;


               1: [Test]
            
               2:
              public
              void Authenticate()
            
               3: {
            
               4: Scenario.New("Logon
Twitter", scenario =>
            
               5: {
            
               6: Twitter
twitterClient = null;
            
               7:  
            
               8: scenario.Given("user
is not logged on");
            
               9:
            
               10: scenario.When("the
user logs on", () =>
            
               11: twitterClient
= new Twitter(username, password));
            
               12:  
            
               13: scenario.Then("it
should be possible to call API", () =>
            
               14: twitterClient.Status.FriendsTimeline());
            
               15:  
            
               16: }).Execute();
            
               17: }
            
               18:  
            
               19: [Test]
            
               20:
              public
              void Get_status_from_friends()
            
               21: {
            
               22: Scenario.New("Get
status from friends", scenario =>
            
               23: {
            
               24: TwitterStatusCollection
friendsStatus = null;
            
               25:  
            
               26: scenario.Given("the
user is logged on", () =>
            
               27: twitter
= new Twitter(username, password));
            
               28:  
            
               29: scenario.When("friends
status is requested", () =>
            
               30: friendsStatus
= twitter.Status.FriendsTimeline());
            
               31:  
            
               32: scenario.Then("friends
status should be received", () =>
            
               33: friendsStatus.Count.ShouldNotEqual(0));
            
               34:  
            
               35: }).Execute();
            
               36: }
            
               37:  
            
               38: [Test]
            
               39:
              public
              void Get_followers()
            
               40: {
            
               41: Scenario.New("Get
users' followers", scenario =>
            
               42: {
            
               43: TwitterUserCollection
followers = null;
            
               44:  
            
               45: scenario.Given("the
user is logged on", () =>
            
               46: twitter
= new Twitter(username, password));
            
               47:  
            
               48: scenario.When("followers
is requested", () =>
            
               49: followers
= twitter.User.Followers());
            
               50:  
            
               51: scenario.Then("followers
information should be received", () =>
            
               52: followers.Count.ShouldNotEqual(0));
            
               53:  
            
               54: }).Execute();
            
               55: }
            
               56:  
            
               57: [Test]
            
               58:
              public
              void Update_status()
            
               59: {
            
               60: Scenario.New("Update
user status", scenario =>
            
               61: {
            
               62: scenario.Given("the
user is logged on", () =>
            
               63: twitter
= new Twitter(username, password));
            
               64:  
            
               65: scenario.When("status
is updated", () =>
            
               66: twitter.Status.Update("hello
world..."));
            
               67:  
            
               68: scenario.Then("status
should be updated", () =>
            
               69: twitter.Status.Show(username).Status.Text.ShouldEqual("hello
world..."));
            
               70:  
            
               71: }).Execute();
            
               72: }

Notice that I’ve used a C# DSL (Domain Specific Language) for describing the tests as scenarios. These scenario driven tests is a well known test pattern called AAA (Arrange, Act, and Assert). I’ve developed the C# DSL and open sourced it – feel free to use it.

The workflow

The workflow is simple. Start out by writing failing tests to document what you need do in order to solve your task. When I started, I had one task, integrate with Twitter, after writing the tests I had decomposed it into four minor tasks. This is a famous problem solving technique called Divide and Conquer. You break down a large, complex problem into smaller, solvable problems. When this is done, you start working on the tests and get them to pass, one by one.

Conclusion

Using TDD to learn new API’s is something everyone should do. If you think about it, it’s exactly what you are doing when you are writing production code and using 3^rd party libraries today. You write some code, you compile it, and then run it. If it doesn’t work, you spend some time debugging. And you do this incrementally until you’ve solved the task. If you do it the TDD way, you save yourself from lots of debugging time and you end up documenting how to use the 3^rd party library.

There are some other advantages as well. When you hand over the code over to other developers, they can use your learning tests to figure out the same thing you had to figure out, but they can do it by reading your code. Besides that, you also document how a 3^rd party library is supposed to work. If they change their API’s or introduce a bug in the next release, your tests will fail, and you can trap this.

Uncle Bob have some good arguments as well;

“If you want to know how to call a certain API, there is a test that does it. If you want to know how to create a certain object, there is a test that does it. Anything you want to know about the existing system, there is a test that demonstrates it. The tests are like little design documents, little coding examples, that describe how the system works and how to use it.” – Uncle Bob

“Have you ever integrated a third party library into your project? You got a big manual full of nice documentation. At the end there was a thin appendix of examples. Which of the two did you read? The examples of course! That's what the unit tests are! They are the most useful part of the documentation. They are the living examples of how to use the code. They are design documents that are hideously detailed, utterly unambiguous, so formal that they execute, and they cannot get out of sync with the production code.” – Uncle Bob

So the next time you have to learn a new API, do it by exercising TDD.

Download the source code

Everything is amazing, and nobody is happy…

Gøran Hansen — Mon, 23 Mar 2009 21:31:26 GMT

A colleague of mine showed me this YouTube video a week ago, and I thought was so much fun that I had to share it with you. Please take 4 minutes to watch the video - it’s worth it. You’ll see the comedian Louis C.K. talks about how ungrateful we are, even though we live in this amazing world with all this fancy technology that makes our lives easier to live.

Louis made some darn good points, and he made me think about how many unhappy fellow engineers I’ve spoken to lately – many. This made me thing about how it would be to work in the early days in the IT-industry, where the tools were much more primitive. In this age of the industry we are capable to create it-systems to automate most of our daily routines, but back then the computers were mostly used in the field of science. Nowadays even grandma can pay her bills using a web browser without leaving her home to visit the bank. This enables her to spend more time doing whatever she think is important, like watching her grandkids. This made me think about a quote I read in The Pragmatic Programmer.

“Civilization advances by extending the number of important operations we can perform without thinking.” - Alfred North Whitehead

So let’s do something fun; let’s have a look at how it was like to be a programmer 50+ years ago, and try to imagine how much work it would take to get the computers to “work” for us back then compared to nowadays .

Programming today and 50+ years ago

Today there are many high level general purpose programming languages. Programming nowadays is more like having a conversation with the computer, and we can express ourselves in a language similar to English.

If you use a statically typed language like C# or Java, you need to compile the code, which will output assembler code (machine code) that can execute on a computer. C# and Java are a special case, because the assembler code runs inside a virtual machine, which means that the assembler code is more high level than regular X86 assembler code. Anyway, this abstracts us away from the nitty gritty details of machine languages, which is hard to program, understand, read and maintain.

So let’s do something fun, let’s implement the Fibbonaci algorithm in C# and in X86 assembler code (machine level code).


               1:
              class Program
            
               2: {
            
               3:
              static
              void Main(string[]
args)
            
               4: {
            
               5: Console.WriteLine("23rd
fibonacci number: {0}", Fibonacci(23));
            
               6: Console.ReadKey();
            
               7: }
            
               8:  
            
               9:
              static
              int Fibonacci(int n)
            
               10: {
            
               11:
              if (n
== 0 || n == 1)
            
               12:
              return n;
            
               13:
              else
            
               14:
              return Fibonacci(n
- 1) + Fibonacci(n - 2);
            
               15: }
            
               16: }

Assembler


               1: .model
tiny
            
               2: .code
            
               3: org
100h
            
               4: rt:
            
               5: mov
ax,cs
            
               6: mov
ds,ax
            
               7: mov
es,ax
            
               8: cld
            
               9: push
23
            
               10: call
fib
            
               11: call
print_eax
            
               12: ret
            
               13: push
bp
            
               14: mov
bp,sp
            
               15: mov
di,offset fib_array+2
            
               16: mov
cx,[bp+4]
            
               17: loop:
            
               18: mov
ax,[di-1]
            
               19: add
ax,[di-2]
            
               20: inc
di
            
               21: mov
[di],ax
            
               22: loop
fib_loop
            
               23: mov
bx,[bp+4]
            
               24: mov
ax,word ptr [bx+fib_array]
            
               25: mov
[bp+4],ax
            
               26: pop
bp
            
               27: ret
            
               28: t_eax:
            
               29: mov
bp,sp
            
               30: mov
di,offset outbyte
            
               31: mov
ax,[bp+2]
            
               32: mov
bx,10
            
               33: xor
cx,cx
            
               34: p:
xor dx,dx
            
               35: div
bx
            
               36: add
dl,48
            
               37: push
dx
            
               38: inc
cx
            
               39: test
ax,ax
            
               40: jnz
divlp
            
               41: e:
pop ax
            
               42: stosb
            
               43: loop
store
            
               44: mov
byte ptr [di],'$'
            
               45: mov
dx, offset outtxt
            
               46: mov
ah,9
            
               47: int
21h
            
               48: ret
2
            
               49:  
            
               50: xt
db "23rd Fibonacci number is "
            
               51: xt_l
= $-outtxt+1
            
               52: yte
db "00000000"
            
               53: array
db 1,1
            
               54:  
            
               55: end
_start

Pasted from: http://cubbi.com/fibonacci/asm.html. Ps: I’m not sure if this code even works.

And yes, I realize that the x86 instruction set is younger than 50 years, but I thought it would be a good example, and it’s still assembler code, which is low level enough! When the C# get’s executed it’s probably going to end up looking something like the assembler code above, and that’s the main trick of compilers - they translate high level languages into low level machine code and instruction sets.

This it’s a nothing more than amazing! In the modern language I used the concepts of recursion, functions, strong typing, classes etc. Now compare it with the Assembler code, which I by the way almost seems like a foreign language to me. This modern language really enabled me to do more with less.

So if you think that the modern languages today are crappy, or they should have been different in any way, you should try to think about what if we had to implement business applications in assembler? Compilers are one of the most technical challenging problems we face in our career as programmers. I think we owe the creators of modern languages a really big thank you!

And if you are in a situation where you maintain crappy legacy code implemented in C#, VB 6, JavaScript etc. Imagine if that code was implemented in assembler - it would be much worse that you can even imagine, and it probably would end up being your worst nightmare. The only one you can blame for bad code in modern languages is yourself and your fellow engineers.

It’s not only the languages that have evolved, but also the frameworks. Today we have tons of commercial and open source frameworks, which also is a key enabler when developing high quality software. The frameworks I can come up with at the top of my head are;.NET, Java, Apache, Hibernate, Ant, CruiseControl.net, Silverlight, Mono, Moonlight, Struts, Ruby on Rails, SPRING etc. And let’s not forget the tooling; Visual Studio .NET, Eclipse, IntelliJ, TextMate, TextMate, SharpDevelop etc. And the funny part is that since we are getting better and better tools, the development speed of these languages, frameworks and tools seems to go even faster.

Nobody is happy?

So even though you are not happy with what you are doing in your daily job as a programmer, imagine how it would be if you had to maintain assembler code, how it would be to write ORM mapping by hand or if you had to use Notepad as you development environment – now it doesn’t seems so awful, does it?

But don’t fool yourself to think that’s something wrong with the languages, frameworks and the tools; a fool with a tool is still a fool! Even though it’s possible to do amazing things, programming is still something that takes hard work and lots of practice if you want to become a master. If you are serious about becoming a programmer, you should know that you have to face at least 10 years of practice to really master it. Programming is really, really hard - period. When it becomes your profession, it’s not only about creating cool stuff, it’s about creating cool stuff with high quality, and it’s the last part that’s hard. I’ve been programming professionally for 8 years, and I still feel like a young journeyman when I read books by Robert C. Martin, Eric Evans, Andy Hunt, Dave Thomas, Craig Larman, Martin Fowler etc. I realize I have still a long way to go before I can call myself a master.

So even though we can do all these amazing things, you still need to learn how to master the craftsmanship of software development, and if you are serious about it, expect to practice for a long time. You can expect much from this industry, but it will also expect much from you! So if you want to become a happy developer, you need to become a decent software craftsman, and expect plenty of work to achieve that!

MSDN Live mars 2009

Gøran Hansen — Wed, 11 Mar 2009 13:23:48 GMT

Som du kanskje vet, pågår det for tiden en runde av MSDN Live, et arrangert i regi av Microsoft Norge. De har allerede besøkt byene Stavanger og Bergen, og kommer til Trondheim i morgen, før de avslutter i Oslo.

For første gang i ~~historien~~ nyere historie så tar de betalt for dette arrangementet, og prisen er 1500 kr. Microsoft har begrunnet dette med at de også er blitt et offer for finanskrisen, og må stramme inn budsjettene som alle andre.

Man kan jo argumentere med hvorfor i all verden vi skal finansiere Microsofts egen salgsturne? Det er jo et arrangement som tross alt genererer flere salg av deres egne produkter. Jeg velger å ikke ta stilling til denne diskusjonen, men heller fokusere på det faglige. Microsoft har skapt en knakende bra faglige arena gjennom MSDN Live. Arrangement er gjennomført med dyktige foredragsholdere og alltid relevant faglig innhold!

Børge Hansen som jobber i Microsoft forklarer på hans blogg hvorfor arrangementet koster penger.

Hvorfor delta?

I vår bransje foregår utviklingen veldig raskt, og hvis vi skal henge med på dette så må vi holde oss oppdatert på hva som skjer på teknologifronten. Selv om vi er midt opp i en finanskrise og budsjettene strammes inn, må vi fortsatt jobbe med kompetanseheving. I dag hørte jeg et morsomt ordtak av en kollega av meg, som setter denne problemstilling på spissen; ”Hvis du synes kompetanse er for dyrt… forsøk uvitenhet”. På sikt vil dårlig kompetanse koste veldig dyrt, det kan sammenlignes med og ”pisse” i buksa når man fryser; først det blir varmt i noen sekunder, før det blir ulevelig kaldt.

Selv om du må jobbe litt ekstra med å få tillatelse fra din arbeidsgiver til å stille på dette arrangementet pga. kostnad, så mener jeg det er verdt det, for din egen del, og for din arbeidsgiver. Dette er en langsiktig investering!

Så har vi jo også det demokratiske aspektet; hvis den totale oppslutningen blir for dårlig for dette arrangementet, så vil vi som teknologer miste en fin arena – noe vi ikke ønsker!

Hvordan har tilbakemeldingene vært så langt?

Jeg har lest på bloggen til Torbjørn Marø, er en systemutvikler fra Bergen og en aktiv blogger, han har følgende å si om MSDN Live arrangementet;

”Dagen inneholdt en rekke, gode sesjoner, og selv om MSDN Live kostet penger denne gangen var det relativt bra oppmøte.”

Du kan lese mer om Torbjørns opplevelse på hans blogg.

Hva bør Microsoft gjøre neste gang?

Jeg har selv ingen problem med å betale 1500 kr for dette arrangementet. På papiret ser dette arrangementet akkurat ut som de tidligere rundene av MSDN Live, og når dere plutselig begynner å ta betalt, så hadde det vært en idé og gjort noe nytt. Jeg har følgende forslag til dere på dette området;

Inviter et stort navn til å holde keynote, for eksempel; Scott Guthrie, Scott Hanselman, Phil Hack, Jeremy Miller, Robert C. Martin etc
Dere kunne ha kjørt et ekspert track ved siden av det vanlige, med foredrag av faglig høyt nivå, som er rettet mot ekspertene i de forskjellige byene

På denne måten hadde dere gjort noe som er helt nytt, og dermed ville det vært enklere å forsvare gebyret på 1500 kr.

Visual Studio 2008 running on a machine with a SSD disk installed!

Gøran Hansen — Tue, 03 Mar 2009 10:20:28 GMT

As you can see, the performance is very good. And by the way, Windows is running inside a virtual machine (VMWare Fusion).

And no, Visual Studio is not pre-loaded into memory. The startup was initialized right after the machine was booted.

NNUG Presentation: OOP Back to Basic

Gøran Hansen — Tue, 03 Mar 2009 10:00:57 GMT

Here are my slides from my talk at NNUG Trondheim 26 February.

OOP - Back to Basic

View more presentations from goeran.

The development of the technology inside the IT business happens really, really fast, and many of these technologies have one thing in common; OO (Object Orientation).

Since OO seems to play an important role in our business, I think it’s important for us as developers to achieve a deeper understanding of the concept. It’s more to it than polymorphism, encapsulation and inheritance.

If you manage to master the OO concept, you’ll be able to “reuse” your knowledge across various new technologies like Silverlight, WPF (Windows Presentation Foundation), .NET, Java, Ruby on Rails and the list goes on. It doesn’t matter if you are coding C++, Ruby, C#, VB, or Java, all of them apply the same concept; OO. Yes, they have their differences, but that’s another story.

Not only will a deeper insight to OO help you learn technologies faster, it will help you to write better code. In my presentation I also talk about 3 of the 5 SOLID principles; SRP (Single Responsibility Principle, DIP (Dependency Inversion Principle) and OCP (Open-Closed Principle). If you don’t know them, please learn them!!

You’ll find plenty of information about good design principles here.