Linus Torvalds’s Lessons on Software Development Management - by sjvn01

Posted on September 27, 2011 by admin

If anyone knows the joys and sorrows of managing software development projects, it would be Linus Torvalds, creator of the world’s most popular open-source software program: the Linux operating system. For more than 20 years, Torvalds has been directing thousands of developers to improve the open source OS. He and I sat down to talk about effective techniques in running large-scale distributed programming teams – and the things that don’t work, too.

Torvalds says there are two things that people very commonly get completely wrong, both at an individual developer level and at companies.

“The first thing is thinking that you can throw things out there and ask people to help,” when it comes to open-source software development, he says. “That’s not how it works. You make it public, and then you assume that you’ll have to do all the work, and ask people to come up with suggestions of what you should do, not what they should do. Maybe they’ll start helping eventually, but you should start off with the assumption that you’re going to be the one maintaining it and ready to do all the work.”

Torvalds continues, “If you start off with some ‘kumba-ya feeling’ where you think people from all the world are going to come together to make a better world by working together on your project, you probably won’t be going very far.”

“The other thing—and it’s kind of related—that people seem to get wrong is to think that the code they write is what matters,” says Torvalds. Most software development managers have seen this one. “No, even if you wrote 100% of the code, and even if you are the best programmer in the world and will never need any help with the project at all, the thing that really matters is the users of the code. The code itself is unimportant; the project is only as useful as people actually find it.”

I’ll add at this point that this isn’t just a programmer problem. I’ve seen entire companies get locked into the idea that “perfecting” the program was everything. They then neglected what the users wanted from the program, supporting the users and so on. Most of us who’ve been in the business for a while have seen this cycle play out over and over again.

Expanding on that second point, Torvalds says that’s why the Linux kernel team is “so very anal about the whole ‘no regressions’ thing, for example. Breaking the user experience in order to ‘fix’ something is a totally broken concept; you cannot do it. If you break the user experience, you may feel that you have ‘fixed’ something in the code, but if you fixed it by breaking the user, you just violated that second point; you thought the code was more important than the user. Which is not true.”

Torvalds concludes, “Way too many projects seem to think that the code is more important than the user, and they break things left and right, and they don’t apologize for it, because they feel that they are ‘fixing’ the code and doing the right thing.”

To that I can only add “Amen!”
On the Importance of Development Tools

I also asked Torvalds about Software Configuration Management (SCM) tools like his own Git version control system. He replied, “I don’t think tools are all that fundamentally important.”

“Now, what is important is that there’s a good workflow for the project, and tools can certainly help with that,” said Torvalds. “But most projects don’t necessarily really need tools. There’s a lot of projects that simply don’t have enough changes to really require any tools at all for their work flow; if you only have a few hundred patches per release, you can maintain those just about any way you want, including entirely by hand.”

Linux is a different story of course. “For the kernel, we have thousands of patches flying around every release, and a release roughly every three months, and so for us the tools really are very important,” he says. “But I still don’t think it was all that big a mistake to just do tar-balls and patches for the first few years of development; it was a much smaller project back then, and it took several years for the lack of tools to really become a problem.”

Besides, “Some tools encourage workflows that are actively detrimental, and I think CVS [Concurrent Versions System, a version control system] for example has caused a lot of projects to have the notion of a ‘commit cabal,’” Torvalds continues. “I personally tend to think tar-balls and patches are actually preferable to that – if only because they make all developers ‘equal,’ and you don’t get the kind of model where certain people have ‘commit access,’ and the rest are second-class citizens. Sometimes it’s better that everybody is a second class citizen than that some people have an easier time at it.”

Torvalds, I should note, knows CVS well and has hated it for years. As he said in a Google Talk in 2007, “I hate CVS with a passion.”

Torvalds continues, “Much more important than the tools is the people. The maintainers, and the mindset.”
Keeping People On Track

And how do these people work together today? I asked Torvalds about the role of the Linux Kernel Mailing List (LKML) in the process. He replied, “I think Linux used to ‘happen’ more on LKML than it does these days. The signal-to-noise ratio and just the pure volume of LKML means that most developers simply don’t have time to really read LKML—at best they scan subject lines. As a result, these days I’d argue that most of the real development happens within the sandbox of single developers, and then email on more of a person-to-person scale is actually how things really get done.”

That said, “That doesn’t mean that LKML isn’t important; it means that LKML has become the ‘public band’ of all those individual email threads,” Torvalds adds. “So what ends up happening is that you have maybe four or five people involved in a discussion about their work, but LKML stays cc’d on the whole thing. That turns what would otherwise be a purely private discussion into something where others can jump in.”

Here’s how it works, “A lot of people actually don’t really ‘read LKML;’ they often auto-archive it, but then react to certain keywords or, more often, [to] key people being involved in the discussion.”

“It also acts as a kind of archiving notion,” Torvalds continues, “so that people can refer to it later, and a lot of bug reports end up being found by Googling for them. If somebody raises an issue, it may well be some odd hardware problem, but if Google shows that it’s been raised several times on LKML in the past, that starts to indicate that it may be obscure, but it’s certainly not some totally isolated issue.”

“So I think LKML is really quite important, but no, it’s not how we keep people ‘on track,’” he says. “All the developers tend to be pretty self-motivating, and they all have sane ideas (well, the core ones do by definition – because that’s how they became core developers, by showing that they had good taste and high motivation). It’s important simply because that ‘public part’ of the discussions are still important, even if in practice it’s often a pretty small core in any particular discussion. Things are simply different when they happen in the open,” concludes Torvalds.
On Delegating – and Staying Sane

Once, Linux was a solo project. It now has thousands of committers and contributors. I then asked, “How much delegating do you these days? Any thoughts on how to delegate to keep one’s sanity and the workflow flowing?”

“If there’s one thing I’ve learnt, it is that you have to learn to let go and not try to control people and the code,” he says. “If you don’t think somebody else can do it on their own without your oversight, you might as well give up immediately as a maintainer.”

He continues, “Yes, I often get involved in small details, but it’s not because I don’t trust people or don’t delegate. It’s because some small detail ends up being brought up to me. Either it’s a bug (and they are almost all just silly small details that got overlooked), or it’s just some workflow issue that bothers me (like me complaining about the developer names not showing up properly in the logs earlier today to one sub-maintainer).”

Still, says Torvalds, “Those details have to be occasional details, not the kind of ‘look over the shoulder of the developer to check everything he does.’ I trust sub-maintainers to do the right thing 99% of the time. And then, very occasionally, I end up complaining loudly about something.” Say, for example, on how the open-source GNOME desktop is, or rather isn’t, moving forward.

So, there you have it. That’s some of the ways Torvalds does it. And, if you think you know better, ask yourself: Have I created a world-class operating system that runs most supercomputers, stock-exchanges, and websites like Google? If your answer’s no, I’d re-read his answers and take a long hard think about how you’ve been managing your own projects.

SOURCE : http://h30565.www3.hp.com/t5/Feature-Articles/Linus-Torvalds-s-Lessons-on-Software-Development-Management/ba-p/440

A must read for a developer!!!!!1

Change in EA's EULA

Posted on September 24, 2011 by admin

“Electronic Arts has updated its Terms of Service Agreement for the Origin platform. Following Sony’s steps, and taking it even further, EA has added a new clause that prevents users from suing them in both class action and jury trial forms. Or in other words, in a scummy move – EA wants you to give up your civil rights. And yet they wonder why so many people pirate their games.”

Clearly , everyone is trying to cover their a** ..

Classes & Subclasses | Class Relationships

Posted on August 25, 2011 by admin

Back To Class

I will be going back to classes again after taking a short break from it. I will be continuing from the previous lesson on classes so pls do refer to it if you are lost or you have not read it before. The post can be found here. Today I will be writing more on the relationships between the classes and how it can be used to take your programming into another level. Besides calling it class and subclass , the relationship also often called parent and child class , just a FYI in case you are wondering what is the different between those two names.

Class Examples

Lets go back to the Bicycle class we looked at previously and then we look into a subclass of it.

public class Bicycle {

    // the Bicycle class has three fields
    public int cadence;
    public int gear;
    public int speed;

    // the Bicycle class has one constructor
    public Bicycle(int startCadence, int startSpeed, int startGear) {
        gear = startGear;
        cadence = startCadence;
        speed = startSpeed;
    }

    // the Bicycle class has four methods
    public void setCadence(int newValue) {
        cadence = newValue;
    }

    public void setGear(int newValue) {
        gear = newValue;
    }

    public void applyBrake(int decrement) {
        speed -= decrement;
    }

    public void speedUp(int increment) {
        speed += increment;
    }

}

And the subclass or the child class ,

public class MountainBike extends Bicycle {

    // the MountainBike subclass has one field
    public int seatHeight;

    // the MountainBike subclass has one constructor
    public MountainBike(int startHeight, int startCadence, int startSpeed, int startGear) {
        super(startCadence, startSpeed, startGear);
        seatHeight = startHeight;
    }	

    // the MountainBike subclass has one method
    public void setHeight(int newValue) {
        seatHeight = newValue;
    }	

}

In order to fully understand the class relationships , we must understand one of the main OOP concepts , called “inheritance”. Of course we all know what is the meaning of the word inheritance but we must now look at it from the view of an OOP programmer. Suppose there is a father and a child , in our imaginary land , flying kite. The father is sitting beneath a pine tree and the child is running with the kite. What can we say about the relationship? Here are a few things ,

Both have similar physical and non-physical attributes , such as arms , legs , eyes , names , address , etc ..
Both have similar similar capabilities , such as reading , running , talking , laughing and so on
But the child has a kite while the father does not have any

So for those which are similar between the father and child , we can say that the child has inherited from the father. Of course father is a human so we can say all human belong to a one distinct class called a “person” class. But for attributes or capabilities , functions , that the child has but the father doesn’t , maybe playing computer games , then we can associate it with the child and child alone.

If you were to examine closely at the MountainBike Class which “extends” or inherits from the Bicycle class ,it has a new attribute and a new method associated with the attribute, which are not available to its parent class. Therefore , if you are to create a new bicycle , you could never set its seatHeight to any value because it doesn’t exist for a normal Bicycle. Only a MountainBike would have the ability to adjust its seatHeight.

And if you look at the constructor of the MountainBike , you would see the word “super” before “startCadence” , “startSpeed” and “startGear” , which is saying that those are the same the parents. The only new value set would be the “startHeight”.

Class Relationships Conclusion

I hope you have a much clearer idea of class relationships and inheritance after reading. Hope to see you again!..

Beginning OOP Classes | OOP | Class

Posted on August 22, 2011 by admin

OOP java Class Example

For the example program on Object-Oriented Programming (OOP) , I will be using Java instead of the usual suspects such as C# or PHP. The syntax of the class will be similar and so are most of the terms I would be using in this post. Here is the code from Oracle website itself , to ensure all the necessary steps are correct.

public class Bicycle {

    // the Bicycle class has three fields or attributes
    public int cadence;
    public int gear;
    public int speed;

    // the Bicycle class has one constructor
    public Bicycle(int startCadence, int startSpeed, int startGear) {
        gear = startGear;
        cadence = startCadence;
        speed = startSpeed;
    }

    // the Bicycle class has four methods or functions
    public void setCadence(int newValue) {
        cadence = newValue;
    }

    public void setGear(int newValue) {
        gear = newValue;
    }

    public void applyBrake(int decrement) {
        speed -= decrement;
    }

    public void speedUp(int increment) {
        speed += increment;
    }

}

Lets take a look at it before we modify it our own liking. For now , pls ignore the word “public” , which defines the permission for this class , eg.who can access this. We will be going through “public” , “private” , “protected” in future posts. For now just take it that “public” means its open to all , which could be good or bad thing as we shall see.

So we are talking about a type called “Bicycle” , which has 3 attributes or fields to describe it , cadence , gear and speed. Besides that , it can also do a few functions , such as “SpedUp” and so on. I think by now you should be familiar with functions , or at least be able to read it. If not , pls read my previous post one more time here.

OOP Terms : Class vs Instance

Here I would like to pause for a while to take a brief look at the differences between “Class” vs “Instance” of a class in term of OOP. Bicycle , which we have defined above , is a class , so is a man or a woman. But every bicycles are different in their own ways and similarly each man and woman are also different. You and me are both human , to be more precise “Homo Sapien” , but clearly there are differences enough to tell us apart from one another. So how do we create , or instantiate , a new bicycle?

Syntax For Instantiating An OOP Class

ClassName InstanceName = new ConstructorName();

Examples ,

Bicycle b1 = new Bicycle();
Bicycle b2 = new Bicycle();

Constructor is a special type of function that is designed specifically to create an instance. The keyword is “new” which creates a new instance using the constructor given. But if you look above , the constructor has 3 parameters , which means it is not the default constructor rather it has override it. Think of it like saying “She is a lady , but very find one indeed”. So she has gone beyond what is considered a lady , same for the constructor we have here. So do you tell the difference between a constructor and a normal function? A constructor has these attributes ,

It does not return anything , not even void. It is just “public class-name”
The name of the constructor must be same as the name of the class , including the first letter in capital.

To make a new instance of a Bicycle using the constructor given , we would have to change our code ,

Bicycle b1 = new Bicycle(10 , 15 , 6);
Bicycle b2 = new Bicycle(15 , 9 , 2);

We now have 2 new bicycles! They are both bicycles but they are not the same. Whatever you do to one doesn’t affect the other in any way. This is one of the main concepts of OOP so pls besure to understand it.

OOP Class Ends!

That is it for now but I shall be going more in-depth into this example and also on OOP theory. Cya!

SQLHack.net

SQL And More!

Tag Archives: class