#include <stdio.h>

int* holy_crap()
{
	/*static*/ int s;
	printf("%i\n", s);
	return &s;
}

main()
{
	int* x = holy_crap();
	*x = 2;
	holy_crap();
}

So, what are we looking at? Well, if you uncomment the “static”, you get the intended effect — holy_crap(), when called for the first time, (prints “0\n” and) returns the address of its static variable; the value in that address is changed to contain a 2, and then holy_crap() prints out “2\n”. This is as intended, and it is a very silly thing to do, but it works and is legal.

And then, you comment out the static as I’ve done, and… it still works? That’s odd… In theory, at least, the allocation of a non-static local variable can take place absolutely anywhere in memory, so the address read and returned by the first call to holy_crap() could be different from the address checked and returned by the second call. Yet, on my compiler (gcc version 4.2.4 (Ubuntu 4.2.4-1ubuntu3)) and on Dark’s, it actually does print “2\n” on the second call to holy_crap().

Granted, gcc does complain: “warning: function returns address of local variable”, but it still works, for whatever reason.

And it gets better! Check this out:

#include <stdio.h>

int * holy_crap()
{
	int s;
	printf("%i\n",s);
	return &s;
}

int huh_what()
{
	int test;
	test = 3;
}

main()
{
	int* x = holy_crap();
	*x = 2;
	huh_what();
	holy_crap();
}

This actually prints “3\n” on the second call to holy_crap()! We could probably reduce this further by removing the initial call to holy_crap() and the assignment of 2 to that pointer, but it doesn’t matter, because this is still some weird shit going on here.

Oh, and, I probably don’t need to tell you this but don’t ever rely on this happening for you! It’s very likely a combination of compiler, OS, and unoptimized compilation. I haven’t tried this in any conditions other than “gcc file.c -o file”, and I definitely do not recommend writing anything like this in any application beyond the most trivial/educational.

Still, any ideas to explain why this happens?

Wait, let me backtrack a minute first: the post in question specified that a language’s syntax should be standardized in the official language documentation, and that any deviation from it should be flagged as a compiler/interpreter error. Forcibly. With no way to relax the setting.

I’m going to let you digest that for a second.

Ready? Okay, here’s the next interesting part:

In the end, this requires only that editors and IDEs used by coders will let the user type stuff and it will make it look right. This is basically just reformatting on the fly, which many editors already do. We don’t need you to type zero, one or seventeen spaces between an if and its open paren, we just need the editor (assuming K&R C) to put exactly one space there. And getting even this right will be easier if there is only one style to worry about. It’s one of those things that those reformatting or style adapting cycles can go to.

(emphasis mine)

Now my epiphany: if the IDE could do this (and there’s absolutely no reason why it couldn’t), why can’t it also do the reverse, i.e. translate the standard form into something you like? And if everyone’s IDEs did that, it would finally let Billy code in his personal style, old timer Gabe in his, and have the assurance that the result won’t have several formatting styles because there is only one style!

Where does all this break down? Well, there are a few things, such as:

• whitespace for emphasis — in the comments thread, there is an example of a tic-tac-toe game board expressed as a continuous array, C-style, formatted into “lines” and “columns”, making it infinitely more readable than the equivalent all-on-one-line version.
• whitespace for emphasis, again — another example was of vertical whitespace (and comments) used as a delimiter for important code, making it stand out.
• uncheckables are given in the article — namely, Hungarian notation, and {get,set} method prefixes.
• IDE standardization was also put forward as a possible bad idea, but I personally fail to see the issue — it’s not standardization, but rather adding to a common feature set requirement.
• On that same point, though, I’d like to add in the inability to edit in Notepad, at least, not with ease. Maybe you have two or three IDEs to choose from, but you will have to use an IDE — Notepad just won’t cut it anymore. Not that it really does nowadays, what with the lack of syntax highlighting, but it’s still a valid point.

For some of these, I can envision some creative solutions, such as some (hopefully standard) special comments used as “hints” for extra whitespace or special formatting for display, while still forcing the generated code to adhere to the standard style — but once we do that, we’re back to square one since all the current style problems will get pushed into the comment hints instead. Maybe there’s a midway point there where we could (at least theoretically) have our cake and eat it, too. Maybe not. Any ideas?

Well, I haven’t read about copyleft yet, but considering that’s mostly a GNU thing, and I’m not GNU, I’d rather make my own license. However, I do like their wording and enumeration of the four basic freedoms. Therefore, my first draft Narc License v. 0.5 looks like this:

[Program Name] is Free Software, as defined by the Free Software Foundation at http://www.gnu.org/philosophy/free-sw.html. Therefore, you are hereby accorded the following freedoms:

• You have the freedom to run the program anytime, on any platform, for any purpose.
• You have the freedom to study how the program works, and adapt it to your needs. For this purpose, the source code is made available at [source code URL] in packages whose names end with “-source”.
• You have the freedom to redistribute copies at any time, for any cost, and for any purpose.
• You have the freedom to modify the program in any way, and release your modifications to the public at any time, for any cost, and for any purpose. You are explicitly NOT required to release modifications under this exact license, or any other. You are explicitly NOT required to notify anyone of your modifications, the release thereof, or of their intended purpose.

In accordance with these terms, please note that:

• I, as the programmer, am not under any obligation, legal or otherwise, to support, assist, or otherwise help with the program.
• I make no promises that the program will function in any sense of the word. While I make a good faith effort to ensure that it will not break, the fact remains that I am only human. I am not to be held liable for any foreseen or unforeseen consequences or side-effects of breakage of the program.
• I make no promises that the program will perform a useful task, or that it is fit for any particular purpose. As stated above, I have made a good faith effort to ensure the software is useful. However, I am not liable for any lack of merchantability or fitness for a particular purpose. The entire risk as to the quality and performance of the program is with you.

However, please note that I have an interest in making the software function and be useful, therefore you are encouraged to contact me at [email address] to notify me of any failings in the program, or to request assistance from me, or simply to state that the program is useful to you.

In short: in return for the freedom to do anything with the software, you are assuming the responsibility that I may not respond or assist with any inquiries regarding it. I will try to do so, but I make no guarantees.

Please be aware that the legal status of software licenses is currently unknown (as of 2008-04-07), and this license may not be legally binding in your legal jurisdiction.

Reviewing courts are hereby asked to apply local law that most closely approximates an absolute waiver of all civil liability in connection with the program, unless it can be proved that an additional statement was made, in writing and signed by me, the programmer, whereby liability is being assumed.

Not having researched the field very deeply, I can’t say if this is similar, in letter or in spirit, with any other software license currently in existence. I also can’t honestly say that I care either way.

You are welcome (nay, encouraged) to comment on any part of the license. I haven’t used it for anything yet, but I intend to release at least TNChat under this license.

ETA: Having read more, it occurs to me that the FSF is mostly concerned with keeping their work free, whereas all I care about is that the version I’m releasing be free. More accurately, they’re worried about “proprietary developers” using their (zomg) free software to make proprietary software (OHNOES!). Me, I don’t care if they do that. I don’t even ask them to tell me about it. I guess if I cared about it, I’d use GPL.

Well, there’s nothing stopping me from switching to GPL later.

ETA2: FSF to the rescue again: this license here is for Non-copylefted free software. Just a step above public domain, in that it doesn’t mean I can’t re-release under different terms later. According to the same page, public domain specifically means “not copyrighted”, and that’s not exactly what I want.

And since I’m stuck on the GNU website, one more piece of reading: Why Software Should Not Have Owners.

ETA3: Having browsed many other sources (no links, sorry; there’s too many of them), I’ve come to several conclusions:

• firstly, it’s a bad idea to lose GPL-compatibility;
• explicitly allowing derivative (or creative derivative) works to be relicensed under any terms is a bad idea;
• GPL is not the only GPL-compatible license out there; GNU APL is an interesting idea;
• shorter doesn’t necessarily have any influence on better, and I like short;
• writing a new license is bad because it’s hard to get right, and fragments the community;
• the Eiffel Forum License, v2 looks good. As far as I can tell, it makes all the points I wanted to make in the above, and does so in a much shorter and cleaner format;

I guess I’ll be joining Sean B. Palmer in using EFL (his reasoning is offered here and resonates very well with me).

Then I’ll need some hard-drive space dedicated to the SVN repository and its soon-to-be-myriad of versions, micro-versions, revisions, and such-like, that make the whole shebang work properly. Of course, some parts don’t really belong in the repository, either because they’re too big, or because they’re not really part of the stuff I wrote. And then there’s other parts that aren’t publicly accessible, but need to go into version control anyway.

In total, all the stuff that makes up narc.ro and subdomains is just shy of 2.3 GB. In there, we have duplicates (remaining from various moves like http://www.narc.ro/man/ -> http://man.narc.ro/ ), and we have just short of 350 MB of images (some of them enormously high-quality), and some 1 GB or so of mp3s (sorry, that part is private), not to mention another 225 MB of “temporary” files, some of which are temporary scripts built to play with some random feature or another. The actually important, personally-written, valuable parts probably clock in just over 20 MB or so. Talk about dense packaging — that’s probably three or four years of development, all fitting in so little space it seems almost pitiful.

Nevertheless, that doesn’t include the millions of previous versions of all the files involved, and with that, the repository would probably reach well over 200 MB, and that’s not counting several small, but important backups of the various databases I’ve always cared about.

Think of it like this — about 90% of the code I’ve written has been lost, because there was no reason, at the time, to save it. This code isn’t that valuable in and of itself — after all, most of the various old versions would’ve just been bug-ridden crap that got superseded by revisions of the same files that didn’t have those bugs. Or else we could be talking about versions of a library that didn’t include some particular function, and when a new page was added suddenly that function was required, and added. So it’s not that big a loss.

However, you get to a point where you look at what you have, and you say “You know, this stuff is barely enough to fill 13 floppy disks, have I really done so little? The old versions, the bug fixes, the little “HACK HACK HACK” comments that got replaced by real code, or the functions that were perfectly good but had to be rewritten to provide a more uniform “look”, or to use a particular new helper function that made the work of debugging a lot easier — all that stuff is impossible to see. So, for all the work I did creating these 20 MB, all I have to show for it is the latest version, with no real sense of how much has gone before.

Which is why I’m changing things now. With subversion now installed (make install finished just as I was typing this), it’s time to give Eris an extra hard-drive, and put all the stuff I care about into SVN. And then run commits every once in a while.

*whistles* I’m on my way… to structured programming…

Therefore, I am proposing the following four acronyms:

CYC?

(mnemonic: “Can You Call?”) — a question about availability and, simultaneously, an invitation for the remote party to start voice chat. Implies the local party’s availability for voice chat (duh?).

CIC?

(mnemonic: “Can I Call?”) — solely a question about the availability of the remote party for voice chat. Implies that, in case of a positive response, the local party will initiate the call.

YCC

(mnemonic: “You Can Call”) — a possible reply to “CIC?” which signals that the local party is in a position to accept voice chat, but would prefer to continue in text.

ICC

(mnemonic: “I Can Call”) — an equivalent to “YCC” (see above), implying the local party is in a position to start a voice chat session, but would prefer to continue in text.

Comments? Suggestions? Post below (note: comments are moderated).