By "product" are you meaning "outcome of the intrastructure", or "what gets sold to customers"? Assuming the latter, the product is a tuple (total bits transferred, speed of transfer). Both are resources that are limited by contention for access to physical infrastructure.

And as we all know the "pipe itself" is free. It costs not a red cent to manufacture fiber-optic cable, nor to lay it on the ocean floor and across a continent, and the relays and switches and routers are all free, as is the electricity to run them. When the pipe reaches saturation and page load times increase and videos cannot be streamed in realtime then you just turn the "bandwidth" dial up a notch and the New Infrastructure Faerie magically creates new pipes and equipment and perpetual energy, and they lived happily ever after.

If all heavy users just left, rates for light users would go up. Total cost remains the same, divided by less users. But its a biased phrasing of the question.

If heavy users never joined (or were capped), rates for all users would be less. There is less contention for bandwidth at infrastructure level so total cost is reduced.

So $85 for 3 months and you get a ton of crap you don't want, or download precisely what you want for $36. Oh wait, you can't do that because the on demand download will only be available after the season airs on cable.

> Writing is just playing slow. Your shortsighted question has no horizon.

Deep meaningful bullshit you speak, hmm?

> If you spend your time just composing, I doubt you intended it heard. If you wanted it heard you would play it for as many as could hear. Honestly musicians should get paid more because they actually work. Composers just kind of wank if they aren't working musicians or write jingles for the needy well-heeled.

So a concert violinist should be paid more than the composer of the symphony ... the composer of course being unable to perform the symphony because it requires 100 instruments.

> On the other hand we don't need an industry for anything , really, From the ground up it can be done at home by a band and some friends with some moxie. From booking gigs by email, to recording,mixing,mastering.

Ah, now I understand. You are unable to tell the difference between a garage band recording done in the garage, and the studio recording of a great song performed by consumate professionals and properly engineered, produced and mastered by other professionals.

> But maybe we should also think about how a world would actually look like if there were no trademarks.

Pretty shitty. Trademarks and counterfeit protection are in many cases excellent alternatives to copyright and design marks. The fashion industry for example thrives with no copyright protection and rampant copying, and it does so because cheap knock-offs are not a substitute for brand names in the eyes of consumers. Trademark protection makes untruthful claims about the origin of a product equivalent to the crime of fraud.

In a music industry with no copyright protection, trademarks and counterfeit protection would be essential. It would allow a musician to say "sure, you can download my latest track for free; but you can buy this original merchandise only from me, and that will help to fund more tracks". Anyone else can make equivalent merchandise, but only the musician can claim (legally) to be supplying the original stuff; so you know when you buy non-counterfeit original merchandise you are funding the artist.

If a well-known painter or sculptor has spent 25 years building up a reputation, and can now demand sizable commissions for their work, trademark and counterfeit protection stops some two-bit criminal from (legally) passing off their 3D printed plaster-dipped statuette as an Original Poncynamus.

In short, the value that we ascribe to a work (or art, or music, or prose) becomes synonymous with our respect for and valuation of the artist, and this association is predicated on the right of the artist to claim his/her works, and to deny anyone else from using his/her name.

As a matter of interest, what would you say is a reasonable term for copyright on books? Also, would you consider it fair to have different terms for different rights, e.g. duplication, translation, adaptation (to screen or stage), and derivative works?

What about talented writers who aren't musicians (or prefer to spend their time composing to playing live)? What about sound engineers (who are really essential to a quality recording) and producers?

Only allowing natural persons to own copyright is problematic for any capital-intensive work that requires multiple creative inputs. A movie, for example. The plot/concept developer, the scriptwriter, the director, the producer, the costumer designer, the author of the score, the musicians, would all have a partial claim on the copyright. Photography and cinematography are protected art forms, as is sculpture and (non-functional) painting; so the cameraman and the set decorators may well have claims as well. The production of a stage play is usually protected against audiovisual capture (without consent), so the actors probably have a claim.

IMHO copyright is too monolithic. Differentiating the rights and the term of each right according to the nature of the work would help. For example the duplication or translation of a book may be protected for 50 years, which the exclusive right to a derivative work may last only 5 years. Adaptations and derivative adaptions would require relatively long terms of protection. Art (painting & sculpture) requires minimal copyright protection - the value lies in the original, so the appropriate IP regime is trademarks and protection against counterfeiting.

Non-transferable copyright is a greedy response from people who think copyright should be a permanent meal-ticket for them. Case in point: in most countries in the world if you hire a photographer to take pictures of your wedding (i.e. pay them a pre-negotiated, large fee to appear and take photos), the photographer - NOT YOU - owns the copyright. Ever time you want to send a picture to your grandma, or post a .jpg on your blog, you have to pay a fee to the photography (who you paid in the first place to do a job, and to whom you have given a right of access to a private event in order to perform said job). Now I have yet to find anyone other than a photographer who thinks that this is in any way fair or sane.

The person who takes the monetary risk in undertaking the development of a (protectable) work should be the owner. If I pay you a salary and tell you to write a program that does X and Y, then I own the resulting work. If I pay you to take photographs of a specific event, and pay for or permit your access to the event, then I own the resulting work. If I commission a painting or a statue, then I own the resulting work. If on the other hand you - having received no payment or instructions from me - paint a painting, chisel a statue, write a program or take a photograph, then you own it, and can dispose of it in any manner you please.

It is sometimes possible to use that style, but generally you will need nesting if you want to handle errors. I can't think of a decent embedded example that doesn't require reams of context, but here's an illustration using shared memory under Windows. Try to translate the following code snippet to the style you suggest:

errno_t get_shared_status( LPCTSTR fileName ) {
    errno_t result = E_UNKNOWN;
    HANDLE f = INVALID_HANDLE_VALUE;
    HANDLE fMap = NULL;
    LPVOID shm = NULL;
    MEMORY_BASIC_INFORMATION meminfo;
    SIZE_T shmLen = 0;

    f = CreateFile( fileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL, NULL );
    if ( f == INVALID_HANDLE_VALUE ) {
        result = E_SHM_ACCESS;
        log( "get_shared_status: CreateFile() failed with error %08x", GetLastError() );
        goto cleanupNone;
    }

    fMap = CreateFileMapping( f, NULL, PAGE_READONLY, 0, 0, NULL );
    if ( fMap == NULL ) {
        result = E_SHM_ACCESS;
        log( "get_shared_status: CreateFileMapping() failed with error %08x", GetLastError() );
        goto cleanupCreateFile;
    }

    shm = MapViewOfFile( fMap, FILE_MAP_READ, 0, 0, 0 );
    if ( shm == NULL ) {
        result = E_SHM_ACCESS;
        log( "get_shared_status: MapViewOfFile() failed with error %08x", GetLastError() );
        goto cleanupCreateFmap;
    }

    shmLen = VirtualQuery( shm, &meminfo, sizeof(meminfo) );
    if ( shmLen == 0 ) {
        result = E_SHM_ACCESS;
        log( "get_shared_status: VirtualQuery() failed with error %08x", GetLastError() );
        goto cleanupMapView;
    }
    if ( shmLen sizeof(meminfo) ) {
        result = E_SHM_ACCESS;
        log( "get_shared_status: VirtualQuery() returned too few bytes" );
        goto cleanupMapView;
    }

    if ( meminfo.RegionSize SHM_V1_SIZE ) {
        result = E_SHM_ACCESS;
        log( "get_shared_status: Shared memory file too small to interpret" );
        goto cleanupMapView;
    } //FIXME do stuff

cleanupMapView:
    if ( 0 == UnmapViewOfFile( shm ) ) {
        log( "get_shared_status: UnmapViewOfFile() failed with error %08x", GetLastError() );
    }
    shm = NULL;

cleanupFmap:
    if ( 0 == CloseHandle( fMap ) ) {
        log( "get_shared_status: CloseHandle(fMap) failed with error %08x", GetLastError() );
    }
    fMap = NULL;

cleanupCreateFile
    if ( 0 == CloseHandle( f ) ) {
        log( "get_shared_status: CloseHandle(f) failed with error %08x", GetLastError() );
    }
    f = INVALID_HANDLE_VALUE;

cleanupNone:
    return result;
}

Here's the start:

    f = CreateFile( fileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL, NULL );
    if ( f != INVALID_HANDLE_VALUE ) {
        fMap = CreateFileMapping( f, NULL, PAGE_READONLY, 0, 0, NULL );
    } else {
        result = E_SHM_ACCESS;
        log( "get_shared_status: CreateFile() failed with error %08x", GetLastError() );
    }

    if ( fMap != NULL ) {
        shm = MapViewOfFile( fMap, FILE_MAP_READ, 0, 0, 0 );
    } else { /*
** Oops - if CreateFile() failed we end up here! */
        result = E_SHM_ACCESS;
        log( "get_shared_status: CreateFileMapping() failed with error %08x", GetLastError() );
    }

As soon as you have a code path for exceptions you need nesting to match the error path with the code that led to it, or you will execute multiple error paths unintentionally. The 'goto' style has the same code order as try...finally would, with the 'goto' itself acting like 'throw'.

This is 2012. C is still used for on-the-metal programming of pretty much any embedded micro other than the Arduino. And C doesn't have try...finally. It has nested if statements, goto, or roll-your-own-goto using switch/for/while/do (which is just a style guide compliant obfuscated form of goto).

Yes. We used to do that in some of our source code bases. I always like how "important programmers" at "big companies" think 'goto' is verboten, but don't notice switch statements with fall-through cases. Because they're sooo much safer ;)

So I reversed that situation, and our incidence of resource handling errors went down markedly. As did our incidence of logic bugs from failing to break out of a switch.

In my opinion, obscuring the logic you're trying to express by using a workaround involving an arbitrarily "approved" keyword, obscures the logic.

Mmm. Yes. Very good class. Let's try again shall we?

Judicious use of GOTO can dramatically simplify resource cleanup when exception handling is not supported

And what is finally? That's right, it's part of the exception handling system. The concept of a "finally block" only makes sense if there are multiple paths by which the block can be reached (the normal path and the exceptional path); otherwise it would just be a statement at the end of the normal path.

Now, what about C? This is an important question because there are still (shock, horror!) some embedded environments that don't have a Java runtime environment. Why not, you may ask? Because they have 2kb code space and 512b memory!

So, what about C? Well, it doesn't have exception handling built in (more shock, more horror!). Instead, C programmers must check the result of each function call and branch to cleanup block if the result indicated an error.

</condescending >

Suit yourself, but I'll take Knuth over Dijkstra: http://pplab.snu.ac.kr/courses/adv_pl05/papers/p261-knuth.pdf.

[citations needed]

Citations won't be found, because the explanation is incorrect. There is no technical issue with compilers implementing 'goto' so long as the destination is in the same lexical scope (C has this limitation). Nor is it worth considering execution context at the level of the CPU, as any high-level loop or branch instruction must be translated into one of a limited number of conditional or non-conditional, relative or absolute jumps. Ultimately whether you use 'goto' or some other control construct you are attempting to express the same programmatic flow, and the compiled instruction stream will be sufficiently similar that it's not worth splitting hairs over.

The reason 'goto' is "considered harmful" is because structured programming theorizes that any computable function can be expressed by combining simpler programs using sequence, selection and iteration; and this provides the opportunity for a constructive approach to program correctness. Dijkstra argues that we are cognitively limited and can benefit from code that is structured so that we can tell at any point where we are and where we have come from (a gross paraphrasing of what Dijkstra calls "coordinates"). But "[t]he unbridled use of the go to statement has as an immediate consequence that it becomes terribly hard to find a meaningful set of coordinates in which to describe the process progress". In other words careless use of 'goto' makes it hard to reason about your code.

Knuth contended that one could created structured programs with 'goto' statements, and provided examples of how 'goto' make the program more elegant.

It is important to realise that the claimed advantages of structured programming are undone by the use of break, continue, or exception handling. There are limited forms of goto, and using them prevents proofs of correctness (under the assumptions of structured programming; other techniques may be available) and reasoning using Dijkstra's "coordinates".