I was wondering if it was good to have this since it makes code less portable.


+14  A: 

Very good practice.

It is called code reuse and this is what programming is all about.

As for your argument about it making "code less portable", that only makes sense in a very low level language such as assembly, and even then it makes it more portable as you can isolate platform specific code into functions.

Good code is made of small, understandable functions. Some people say that a function that is longer than 30 lines is too long.

Well, actually it's called "programming"
Marco Mariani
Actually, in assembly code it makes even more sense to use function libraries, because it is so hard to write anything correctly.
@Neil Butterworth - Yes, I had made that point too :)
I learned a long time ago that the optimal length of a function is less than or equal to one screen height.
+4  A: 

Yes. This is the basis of programming. It in no way makes the code less portable, rather the reverse.

+1  A: 

Unless you are going to have one just one big function that is your whole program (and you will be able to do complex things only with spaghetti code) you will be forced to invoke other functions so I don't see the point of your question.

Actually if you encapsulate functionality inside a function and use it all over your program you will:

  • save a lot of lines of code (reuse)
  • avoid having to fix many things instead that one
  • keep high readability
  • keep high maitainability: change just the function and it will change whenever you call it)

So please call functions that you wrote from other functions, it's how it works, it is just great.

+1  A: 

It's good practice not to write very long functions. That usually requires the use of other self written functions.


I would say yes.

If you have a functionality that can be broken down into 2 logical pieces, possibly reusable, do it.

All big APIs use internal components, and often even public functionality makes use of other public functions.

For example:

ShowPage(url) {
    request = new Request(url)
    response = request.Send()
    page = response.GetHTML()

can become:

RetrievePage(url) {
    request = new Request(url)
    response = request.Send()
    return response.GetHTML()

ShowPage(url) {
    page = Retrieve(url)

Now RetrieveUrl can be reused, for example by a function searching a website for some kind of content.

+2  A: 

In procedural and Object Oriented code - yes, though at some point you'll want to review what you've got & see if a library/etc should be dedicated to the functionality you need.

In SQL, no. SQL is set based, and abstracted functions/views/stored procedures are brittle and tend not to perform as well as re-writing with as little function/etc use as possible.

OMG Ponies
+1 for SQL being set based. Although some DBs allow inlining of pure-SQL functions which fixes this in some cases.
I'd upvaote this a million times if I could. Practices good in OOP are not always appropriate or good in the set-based database environment.

You just described programming. Familiarize yourself with:

Reusing "stuff" is one of the primary tenets of any engineering discipline, not only computer science.

David Titarenco