Standardized Programming

The idea is create a Set of Programming Rules and Methodologies with the primary purpose of uniting Programmers in code.

I understand that there are literally a gazillion ways to write code, but, WHAT IF, there was only one way. Imagine a standardized method of coding.

> Imagine a standardized method of coding.

All I can imagine is a language that drops the features I want.

I guess it could work for skilled programmers, e.g. all in a single company or something. But the reason average/beginner programmers do certain things is because they don't know better than that. A beginner might not use inheritance and use an alternative method.

@dynaman: Its a Set of Programming Rules and Methodologies for a Language. Its an agreement, not a Language.

@CS_TBL: Lets say its for a Procedural Language like B3D. Here again the programmers would have to agree to the using the rules in order for the code to certified.

Hmmm...perhaps a panel of coders would be responsible for certifying standardized code compliancy.

lol...wouldn't work. It would be like forcing all artists to only use certain colours in certain ways, with a certain size brush.

You mean like at work.

Where there generaly is a standard, which no matter how good you are you fail to maintain for the first X Months.
(Were X is dependent on how locigal you think the standard is)

There already are. They're called best practices.

Then you'd have a highly compact language, that complies to the Single Point Of Truth rule. Like Haskell.

Okay. Now what? I was thinking of Java's best practices. How about you?

It would have to be. If a rule isn't enforceable, it's not a rule by definition. More of a guideline, as it were.

Then it wouldn't be applicable for an Object Oriented language (like Java) or a Functional language (like Haskell).

Also there is precious little one can do to standardize a procedural programming language, other than naming conventions.

Well this works for large open source projects, but outside of a given work environment, a standardization would be meaningless.

@boomboom, I fail to see the coorelation, a programming language has a Syntax which is the first level of Rules. Higher-level Rules only require an agreement to use them. The idea is to approach coding mechanically not artistically.

Naming conventions are a good start and are applicable to OOP languages as well!

No they aren't - at least not the same conventions.

Why not. Please explain.

> @dynaman: Its a Set of Programming Rules and Methodologies for a Language. Its an agreement, not a Language.


Flameduck beat me to it. Without enforcement from the language there is no such thing. Or to put it another way, in order to enforce rules the base set of assumptions those rules are based on has to be static. Some rules work in one language but not another.

(Or maybe I've just been around too long, I've never seen rules get applied consistantly - somebody always breaks them)

Boss just makes you re-write it.

"I dont care if it works or its more elegant or faster. It doesnt stick to the prescribed standard. So do it again"

I agree enforcement could be tough. Perhaps a Compliancy Committee could inspect works for compliancy and stamp the work with a Logo of Approval (Certification).

Is this for the sake of conversation or are you planning on implementing a scheme?

Ah, I've only just realised this is a windup. You had me there for a bit. Very Funny

There are standards at the smallest level of computing and I believe that a 'High Level' Programming Standard can be adopted by B3D Programmers for organizing and sharing code. Just imagine how easy it would be to share and expand others code who are using the same coding "Standard". Everyone on the same page.

The idea here isn't to smother creativity, but, improve it through concise communication.

@H&K: There is no windup. I merely compare the possibility of a 'Seal of Approval' to others already in use. We all look for 'Seals of Approval' on every product we buy to assure us of some level of "quality." This "quality" is enforced by a group of folks who use some set of "standards". I don't understand why a 'Seal of Approval' cannot be applied to Programming.

@Nomen luni : I don't have a scheme. Yet. Naming Conventions would be a good place to start. In fact, Naming Conventions are the basis for my own Label-Oriented Programming Methodology.

I dunno how relevant this all is. I can't imagine working with more than one person on 1 function or class. A complete class/function however, with all the inputs and outputs clearly documented should be solid enough to move around anyone's code. What's in that class or function might be a large pigstein, but as long as it works, it works.

This is the kind of stuff that holds back programming and programmers. FPS, you really should take a few months to get to grips with Lisp and you'd see not only why something like you're proposing generally won't work, but why it's ultimately counter-producitive to programming as a whole.

Well, I suppose it may serve in languages whose expressiveness is heavily restricted by design. Of course, once you move to a more expressive language, it is painful to move back - and you'd never willingly castrate your expressive powers.

Because one language has features the other doesn't. For instance in Java it is customary to use descriptive names in CamelCase, and start Class names with an UpperCase letter, and everything else with a lowerCase letter. Something like that could not be applied to Blitz3D because it doesn't have classes.

Sure. But here's the deal. Enforcing coding standards if not done by the language (Python, Lisp, Haskell) or the IDE (Eclipse, X-Develop) is a horribly boring task, that takes one full time position, on even a small development team. Now imagine scaling that up to a community with potentially 1000's of members.

Because there's no universal metric for quality. Even something like ISO 9001 certification doesn't mean it's high quality. It just means it isn't a worse quality than it was yesterday. In programming the metric to measure this quality is normally unit tests (for other developers) and acceptance tests (for customers). However it is impossible (and pointless) to create generic (and thus standardized) tests for applications that serve even marginally different purposes.

Exactly. Encapsulation and Black-Boxing work.

And you prove this with your unit tests, and that's how quality is theoretically evaluated. Around here tho' people tend to care more about track records than working software.

I would. I'd trade it for proper syntax that doesn't use Polish Notation any day.

@CS_TBL: All true points. However, assuming that you are an experienced programmer in a specific language, I'm confident that you use a specific set Coding Rules for yourself in using that language. This is a Standard. Now imagine if others used the same exact rules.

You would be able to easily read, organize and expand their code even without documentation. I would wager, that it would be difficult for you to tell the difference your code from others.

And that my friend lies the issue, Coding Style. Many desire to have their own Coding Style, and consider programming to be some form of artistic expression. I would firmly disagree, ending my debate with: "What's in that class or function might be a large pigstein, but as long as it works, it works."

I know someone who's greatly dyslectic. He invented, tho, some kinda odd language he reads/writes perfectly. His characters really look alien, remember the movie Predator? Those kinda odd symbols. Once he lost his noteblock with all his writings, the police found it, but he had to explain at the police station what all those signs meant. :P The point is: someone may be blind for a seemingly normal thing (our language) but perfectly capable to read something, as weird as Martian language, of his own.

Same with code. I'm perfectly able to read my own code, and I'm barely able to read someone else's code. Black box method doesn't require one to be able to read code, it's only required to be able to understand the inputs and outputs of the 'machine'. I don't think one could ever really standardize things, but with encapsulated black boxes everyone should be able to survive.

I could tell you my standard rules, FD could tell you his standard rules, Grey Alien could tell you his own standard rules, Mark, Skid, Puki (puki?), H&K, ziggy, etc. etc. etc. I'm sure all are slightly different.

CS_TBL: Interesting Alien Story. I'm sure if the Alien taught others to read Martian, others would have no trouble understanding the writings. Heck, someone could write a program to translate them. LOL.

Ok. I hear many reasons as to why a Programming Standard will NOT work. Can someone reverse roles and play Devil's Advocate. How can a Programming Standard work?

btw, I'm pretty sure that these dyslectic situations also are the reason why people keep making editors that do the same all other editors do: they can't manage to work with the existing stuff, therefor they make their own. I 'suffer' from this situation a lot.. :P Rather than invest time into a ready-made map editor, I rather make my own.. in some cases this is actually required as not all the features I'd wish for are supported in the map editors that are around, but on other cases it's just laziness or blindness really. Sometimes I figure that it takes me more than a week to find out how a map editor works, then I make my own as that only takes a few days.. :P

Has someone got an essay to write? ;-P

Not really. I don't have a standard way of programming - or rather my standards evolve as things change. I think it's important to evaluate your preconceptions once in a while, just to find out if they've been obsoleted.

Didn't we cover this already? A programming standard can work if the language used has a SPOT, and the compiler simply refuses to compile garbage (anything that is not standards compliant). Examples include Haskell, Lisp and Python of which the later is by far the most humanly readable.

Also XML/XSD are fairly good examples (for declarative languages) for a standard that works. The reason? Most parsers will not allow you to use illegal (non-standard) syntax.

So is it possible for a group of programmers to agree on a Naming Convention?

Yes. I heard of one project (I won't name the company) where the convention was to reference the requirement number and design in the name for functions. So there were function names like R103_UC5S8_CalculateHeading(). Not particularly useful or easy to remember, IMO.

If you divide your stuff between types, then the naming comes automatically.

I tend to use as little variables as possible. As far as I can see at first glance, there are 2 types of variables: storage variables and usage variables. Storage variables for me are simply type fields, and usage variables are usually counters 'n temporarily things. The latter not being all that shocking. x,y,z,i,t,r,g,b,ox,oy,nx,ny,sx,sy,dx,dy,temp etc. I'd almost say that a handful o' them is really enough for most functions, it's almost like registers in asm. As for type fields, also compact/short for me. Each type has its own namespace, so it's no problem if all your types have an x and y field.

LOL. That is probably the single most ridiculous naming convention I've ever heard of.

CS_TBL: Very interesting. I've used this. for years. Maybe its just me, but, after coding for so many years with B3D I started to see common patterns in my code constructs. I have turned these patterns into templates which I use code wizards to generate. Until I developed a personal standard all I had was Speghetti.

Nomen luni: Yeah that naming convention looks crazy, but, if the R103_UC5S8_ is the is the name of the object and all the constructs associated with that object start its label with R103_UC5S8_, it would be easy to remember.

I'm not a big fan of standards, as anyone who's used my now-defunct Xml module could probably tell you (I more or less threw them out the window). There are good practices, but standards are a waste of time because they are inherently limited to the situations they are devised for. Upon encountering a situation your standards cannot account for, you must then break standard and use a practice not yet approved of by your unusually twisted mind.

In short, screw standards, I'll just come up with a style as I go and stick to it throughout a project for the hell of it. I usually end up deviating a fair amount throughout the project, but it's all still coherent and the code does not lose efficiency or readability in favor of unusual rules that need to be bent in order to do anything useful.

Excuse me while I go take a couple more painkillers.

There is obviously a lot of prejudice against the word Standard. Perhaps the word Framework is more suitable. LOL.

I wonder what would happen if the inventors of IP would have said "Screw Standards." LOL.

The other problem with standards is they are painfully slow to adapt to new situations. You could almost say that language restrictions are 'standards' in that sense - it's a standard that in BMax there is no way to define your own conditional compilation.

That's what's nice about Lisp. You just redefine your own little localized piece of the language with a macro and you've just added your own standard (i.e: new localized syntax for defining binary classes) - but because it's a feature of the language itself it can compile on any standard Lisp compiler.

There is a time and a place for standards (like your reference to the IP specification), but that doesn't trickle down to all levels of coding.

More or less, I'm in complete agreement with Noel's post above.

I'm officially using the word Framework from this point forward. LOL.

I'm having a difficult time grasping what is meant by New Situations? If you must work in the realm of a specific Syntax, what defines a new situation? Can someone please explain (an example also welcomed).

Is it not possible for a Framework to be comprehensive enough in scope to cover these new situations? Is not possible to for new rules to be added, unuseful ones removed?

i'm coding standardized. i allways do things the same way, and i mean EXACTLY the same way. eg. i tab my code and i leave spaces between +i*/= signs.

Well that depends on what you're trying to say, as they don't mean the same thing.

There are currently 10 different (mutually incompatible) standards concerning the Internet Protocol (conveniently named IPv0-IPv9).

Exactly. It's taken about 10 or so years for ISPs to switch from IPv4 to IPv6 for example.

@Devils Child: Would you mind sharing some of your coding Standards?

@FPS: look into my code-archives :) i'm sure, you will see that it looks all exactly the same. i always use upper and lower case the same way.
i define at the start of my program the screen resoultion and other stuff, then types, globals and arrays. i allways have these functions in a game:
Menu()
Game()
InitGame()
FreeGame()
UpdateGame()

and so on ... :)

@Devils Child: Very Interesting. Those functions look similar to my objectNew, objectDelete, objectStart, objectStop, objectUpdate Functions that I use practically for every object. I now use Code Wizard Templates to generate these functions.

My coding style is similar to Devils Childs.
With a few extensions:

1. Functions with parameters are always styled the following way

function blub( param1, param2, ... )
this means space between params and at the beginning and end of the ()

2. I never use the lazy programmers numeric type shortcuts. The moment one is too lazy to write :int instead of % he should stop coding. a regular code will have ten tousands of letters, +-3 won't make a difference, will just make the code harder to read and maintain

all above that are applied OO paradigms and patterns for code design etc

Please elaborate. Thnx in advance.

The only non-written type I use is the $ for string .. :P matter of habit. ^_^ (BlIde makes that a :string anyway)

@Dreamora: Just figured out you are refering to BMAX. No elaboration required.

I find it very interesting that 4 different programmers have a developed a programming standard for themselves with very similar rules. Now, if only they could all come together and AGREE on a single Collobrative Framework. Hmmm...

No they haven't. For starters many things (like indention) is just plain common sense. Secondly because functions have similar sounding names, does not automatically imply that they have the same function. Thirdly not using shorthand type specifiers is a matter of readability - the average person can remember 7 things give or take 2 at any given time - if you need to remember which is integer "#" or "%", that leaves you 6 other things you can remember. Explicitly using :int or :float simply frees up one of your memory "slots" so you can have more of the language idiosyncrasies in memory at one time.

All of the things mentioned so far are fairly benign things that any sufficiently competent programmer would consider common sense, including CS_TBL's poor naming of throw away variables.

What about things like chaining methods? Should every method explicitly "Return Self" at the end? So you can do stuff like blah.update().draw().reset() in one line? Some would say yes, some would say no. Some would question whether it's even always possible.

Another thing is indentation of assignments. For instance do you assign variables like this:

Local Name:String = "FlameDuck", Rank:String = "Private", Number:int = 1337, ChallengeRating:String = "Poor"

Like this:

Local Name:String = "FlameDuck"
Local Rank:String = "Private"
Local Number:int = 1337
Local ChallengeRating:String = "Poor"

Or like this:

Local Name:String            = "FlameDuck"
Local Rank:String            = "Private"
Local Number:int             = 1337
Local ChallengeRating:String = "Poor"

Also do you use CamelCase (ChallengeRating) or Underscores (Challenge_Rating). Do you use ALL CAPS for constants and if so, do you use underscores to separate words, and how do you simulate type-safety in a language that doesn't have TypeSafe Enumerators (like Blitz3D and BlitzMAX)?

Do you use Hungarian Notation, and if so, how is your bastardized variant (because the traditional variant is woefully inadequate)? Do you have some sort of name manging in place to prevent symbol clashes between your code, and someone else's code (or worse, DLL)?

What about unit tests? Are you using ad-hoc tests, in-line tests or separate tests? Are these part of your standards, or imposed by 3rd parties (like JUnit for instance)?

I'm not quite sure what you mean by Collaborative Framework, but Trac, MediaWiki and Sharepoint are all rather popular. Wow. Can't even agree on one standard for collaboration. Do you think that's because different people have different wants and needs?

Programmers have different values, popular ones are productivity (how long would it take me to do task A), functionality (how well does task A work), usability (how easy is it to do task A), performance (how long does it take to perform task A), supportability (how much time does it take to change task A into task B), reliability (what happens if task A fails). No matter what task at hand, corners are going to have to be cut, so you prioritize which are most important to you, and your coding standards (and to some extent choice of language and platform) are going to reflect these priorities.

hey! what's poor about x and y to fill a 2d array? What's poor about sx, sy for source, dx,dy for dest, ox,oy for old, nx,ny for new? :P

As long as one knows what those vars mean -and be consistent with it- there's no problem I'd say.. ^^

Well I didn't know (instinctively) what they meant. I could probably have guessed, and probably gotten them right if I bothered reading the source code.

They're poor, because they differ from a sensible standard which would promote more verbose variable names.

I would use at least something like DestXPos or SrcXPos, if I where consistent (which I'm not, by the way). I realize that the rather limited functionality of the BlitzMAX IDE kind of encourages you to write unreadable and ultimately unmaintainable code, but thankfully there are now alternatives - although they mostly require .Net.

Err DY would be for "Change in Y" - "Delta Y", so there you are, confict already, and weve only just started

Stop calling it Framework, cos thats not what you mean. People have less problem when you say framework, cos its not what it is you want, you want stadadization.

We already have Hungarian STANDARD notation, yet how many of us use it? I only use it when Im forced to. So go ahead form a coding police.

I prefer short vars as longer ones tend to obfuscate my code a bit. Ohwell, 100 programmers, 100 different styles 'n opinions! :P

Well you need to stop cramming as many instructions as possible onto a single line then. :o>

Plenty of assumptions in that one.

How about a Framework for Standardization? Hungarian STANDARD notation...sounds interesting. Me investigate.

True. But the objective is for an Agreement on a single method. I'm fully aware that such a collaboration is practically impossible with 'old dog' programmers. I do believe that such a framework would appeal to noobs.

PS: I love verbose var and function names.

Well you're entitled to your opinion. The idea that people who don't indent are high in the common sense department is a highly alien concept to me. Either you indent, or you're retarded.

Which definition of framework are you using in this context? A "Framework for Standardization" is nonsensical. Either you have (and are able to enforce) standardization, or you don't have a standard.

Yes. Well it's not. It's not even a standard (so much as a mnemonic technique), and it's not consistently used (except by the people who worked on MFC, although they used it in a way that was ultimately pointless, as C++ is a statically typed language).

Yes I realize that's what you're getting at. Unfortunately you fail to realize that there is no such thing as a universal truth regarding programing. That's why there are so many different paradigms (and implementation of said paradigms). For instance C# and Java are both single paradigm object oriented languages. However in C# every type of data is an object. In Java (and BlitzMAX) not everything is an object, some things are simple data types (which is why you cannot add for example an int to a list without first "boxing" it in an Integer object).

Maybe we're talking past each other, but I find it would be quite the opposite. Experienced programmers understand the benefits (and pitfalls) of implementing code standards. Inexperienced programmers, not so much, so it would take them longer to adapt.

I'm not retarded... I'm special!! :p

that said, I do indent.. hehe

Yes. Well they're not mutually exclusive. :o>

Hehehe

FlameDuck: haven't your team decide on which engine to go for yet?
How long have you been looking into what is going to suit you best?
I seem to remember you talking about it for a long time. (ie. a year or so?)

Well yes we had (TV3D). But there was a huge drama, that resulted in somewhat of a setback (lets just say it was due to creative differences) which essentially split the team in 3. So the faction I ended up with chose to start from scratch.

I'm fully aware of that fact and there doesn't have to be.

What I propose is one set of rules for a specific language that is accessible to any Programmer of said language. Programmers choose to follow this set of rules of their own free will. For the purpose of explanation, lets call this set of rules, the Blitz3D Framework of Standarization or B3DFS for short.

With B3DFS, I also propose a group and individuals who demonstrate expert knowledge in its ruleset be empowered to review Source Code for compliancy and award a Certificate of Compliancy to Programmers whom source code is compliant with B3DFS. This concept is no different than assigning a Moderator to a forum.

Certificates of Compliancy could come in the form a Fancy Logo w/ ID# that Programmers advertise with their source code. This advertises to other Programmers that source code is written a specific way using the set of rules in B3DFS.

My key point is that the Programmer has the OPTION to use B3DFS or not. If they do use it and certify their source code, other Programmers who use certified B3DFS Source Code are empowered to read and expand that source code.

I'm not sure why people should even bother, FPS.
It's not like there's a huge userbase using Blitz Languages.. and those who do normally just go about coding the way they like.
And even in this small userbase of people, there's only a little percentage of those, who's actually releasing source code snippets..

Now if you *do* happen to find some useful sourcecode for your project in the archives, isn't it too much to ask that the author is supposed to follow some arbitrary coding style (standard), just so that you can cut and paste it into your own source, without bothering to sit down, read it, and actually learn what the code snippet does?

I know this might come off a bit harsh to some, but I really don't see why you expect people to "bend over" and follow some coding "rule" incase they should happen to let someone else look at the code..

-> blackbox method <-

*lol*
Yeah CS_TBL, thats actually the best one ... don't show it off then it can't be wrong ;-)


I don't add the type to the variable. If I want to know it I just say: get Blide or ask yourself what type it holds ;-)
No in the end I know what it holds.
My vars are normally camel case (I was teached the multi word underline stuff by bertrand meyer in SE but I don't agree that this stuff is of any real readability) and I use different prefixes:

c: Constant
m: member, not meant to be used from outside
s: static / shared
sm: static member
T: for classes
S: Singleton classes
F: Factory classes

No all caps for constants, although I agree up to some point that it makes it easy to directly realize that it is a const. But it breaks the visual consistency of the code for me, thus c

Most BM users tend to use _ instead of m but I learned that this _ can easily be missed depending on the screen resolution and color settings so I dropped it again.

Beside that, I used to use the generala intend (example 3 of FDs assignement examples) but switched back to space = space again as it got really unreadable with different lengths of variables etc.

Providing they're working on a specific project or sub-genre?

And equally ineffective. What would be the incentive for an expert programmer to look through potentially thousands of lines of other peoples code, to ensure that it complies to a set of arbitrary rules?

How is that different from the current situation? You can do that equally well without standardization, particularly since Blitz3D was not designed in a standards-friendly way, and the IDE goes out of it's way to make standardization more difficult. Never mind that standardization is impractical in a procedural language with limited scope (like Blitz3D) as it'll lead to all sorts of symbol collisions.

Unfortunately due to lack of language features, you can't really black box Blitz3D programs. Even BlitzMAX is (due to the lack of working access modifiers) somewhat difficult to blackbox, as you cannot properly control the exposed Interface.

I don't get it tho'. What exactly are you proposing here? How is it going to work with a primitive language like Blitz3D? What is the point? It's not like Blitz3D allows you the flexibility to use it in more ways than one. Blitz3D already has it's own standardization (enforced by the language - like all types must be stored in lists etc.), trying to diverge from that seems rather counter productive and frankly rather pointless.

Let me clarify. One possible set of rules of many.
Never said anything about diverging from the Syntax.

Last Post

First Post

That not "Clarify", thats "Change what I said"

Ok, I admit, I've skipped over the thread, so I may have missed this but one question springs to mind.

Aside from creating a new excuse to make remarkably pretty and complicated flow charts and diagrams, and tell people what to do.. why?

getting people off from posting unreadable 6th class code in the beginners board that they better should have kept for themself.
At least Mark removed Goto from Strict and non strict is not acceptable. otherwise spaghetti coders would still drop the niveau to 0

Whats wrong with remarkably pretty and complicated flow charts? LOL.

@H&K: I was clarifying the context I used the word "one" in.

I was clarifying the context I used the word "one" in
No you were not, you were trying to backtrack.
Oringionaly you wanted ONE SET OF rules to replace the gazillions, now you are saying you ment ONE SET OF rules amongst gazillions

Your right, I stand corrected.

Hmmm, I'm seriously considering expanding upon AOBPwB3D into the Blitz3D Framework of Standardization . Dreamora would you have any disagreement with me adopting some of your standards?

Were does the "Standard" bit come in then? If you have "many", or hell even "a few" you don't have a standard.

Except that would be pointless as his conventions are geared towards BlitzMAX and an object oriented paradigm, so would be useless in Blitz3D where there are only ever 2 types of variable scope (Global or not global) and 4 types of variables Integer, Float, String and Type. There's no point in applying design patterns (like Singleton or Factory) because the language isn't type safe anyway, and doesn't have a mechanism to prevent you from creating more than one instance of a type.

Well that can't be the point at all, because people who write 6th class code (whatever that is) are not the kind of people who adopt arbitrary standards. How long do you think it takes a person new to Java before they get accustomed to using the Java Programming Style Guidelines? Try "Forever".

The degree to which they are superfluous? Besides if that's best reason you can come up with, I think it perfectly illustrates exactly how bad an idea this is.

I program Blitz for fun, which I suppose is why a majority of people here use it. Who can really be bothered with all these standards and documentation? Common sense goes a long way.

1. Indent always
2. Meaningful names for variables
3. Don't use globals unless there's a good reason
4. Rem statements to provide an overview.. not one per line!

At work we have to do everything by the book, all the documentation, design UML, coding standards. The reality is that I sit down and hack my code in before I do the UML, bacause I think it's more useful to encounter the issues hands-on rather than with a piece of paper. If I have to re-write later, so be it.

FlameDuck, did you notice the title of the OO website? 'Applied Object-Based Programming with Blitz3D'

It is clearly geared towards Blitz3D?

FPS, why don't you stop trying to convince everyone they need a standard. Just document one up, use it yourself, and if other people need more structure in their code then they can use it too.

You can't force it upon anyone, so just get on with using it yourself :)

Yup. Although appearently, common sense isn't as common as its name leads us to believe.

Yes, well the title is somewhat misleading. It should be "Pretend Object-Based Programing with Blitz3D". Unfortunately in his effort to cram Blitz3Ds syntax into a Paradigm it was never intended for, means you get all of the disadvantages of using an object oriented approach, but none of the real benefits (encapsulation, polymorphism, abstraction).

Yes. Which is part of the problem because Blitz3D already imposes its own standard on its users (Types are always in a list, etc.).

How so? It is Object-Based, not Object-Oriented. LOL.

Because this is a great debate. I really enjoy the reactions I'm getting, both pro and con. In fact I have found educational value in this debate, perhaps others will as well.

There are standards at the lowest level of computing which allow for interoperability between different Hardware and Software manuafactures. I believe a High Level Programming Standard would provide interoperability between Programmer's Source Code. Some agree and some don't. That's OK.

Which is the motivation behind AOBPwB3D. However, I envision is a more indepth B3DFS with a certification process. If Microsoft, Cisco, Nortel, and countless others can have one, why can't I?

Yes I can. YOU WILL USE MY STANDARD. hahaha.

you can't have 1 standard, everyone doesn't think the same.

You can have one FPS! write one up, put it on the net and let us make up our minds wether we want to use it. Either way you will have your own standard then to keep your own code readable.

But its not a great debate, everyone said you were wrong, you agreed. No debate.

Sure. But it isn't object-based either. An Object is defined by three things. Identity, State and Behavior, traditionally Reference, Fields and Methods.

Because Microsoft, Cisco, et.al. are market leaders.

Come on Flame, be fair, if FPS wants a "Framework of Standardization" just for himself then he can.
Its the fact that he expects us all to stick to it and win a Blue Peter badge for our programs thats not going to happen

If standardizing your code is taking your development time, more than actually making your application work. Then reconsider your needs.

What I propose is one set of rules for a specific language that is accessible to any Programmer of said language. Programmers choose to follow this set of rules of their own free will. The idea is create a Set of Programming Rules and Methodologies with the primary purpose of uniting Programmers in code.

On the contrary, I can develop code much faster because I know how I am going to organize it. I also have tools such as Code Wizard (based on the said standard) to produce code.