Slashdot Mirror
Are There Too Many Standards?
CyNRG asks: "Lately, I've been reviewing the different programming and protocol standards in an effort to guide my career in the most fun and profitable direction. The proliferation of standards is astounding! Choosing which path to follow is more like a trip to Las Vegas. Standing at the craps table in Ceasar's Palace at 3:00 am: do I play the point? Big 6 or 8? Play the field? How about covering the hard ways? The world is using technology more and more, so I would expect more standards based on that fact. It seems like common knowledge, vis-a-vis Microsoft, that companies try to put forth 'standards' in an roll of the dice to make their 'standard' defacto. Are there too many standards?"
No.
Set your standards a little lower, and see how that works out for you. ;-)
while true ; do echo this is my sig; done
"The great thing about standards is that there are so many to choose from."
However, if you think this is bad and that there should be fewer standards, then let me susggest a new saw: "The one thing you can never say with confidence is 'Things couldn't get any worse.'"
Post may contain irony: discontinue use if experiencing mood swings, nausea or elevated blood pressure.
The good thing about standards is, there are so many to choose from!
The Web is like Usenet, but
the elephants are untrained.
You should choose either "Pass" or "Don't Pass", bet the maximum odds you can after the point is established and do the same for two "come" or "don't come" bets.
This will give the best odds to walk away a winner (with the house keeping a razor thin edge).
The policy of the United States is worse than bad---it is insane. -- Ludwig von Mises, Economic Policy(1959)
What examples are there of too many _open_ standards causing a problem?
Except for a large scale distributed effort, (whose conclusions would be ignored anyway), there is no reasonable way to evaluate ALL existing standards.
And you don't need to. The first step you need to take is to narrow the scope of your search by first determining what you think is fun. After that then try to determine what directions within your "fun" domain will be profitable. Once you have a few likely prospects (directions) you then look for employment in those directions. Once you have employment, your employer will give you direction about what is important to them for whatever work you are doing. At that point you will have the information you need to select the standards to apply to whatever you are building for your employer.
(After doing all of the above then,
1. Code
2. Profit )
(I, for one, welcome our over abundant standard bearing overlords.)
Avoid the hard way bets and big 6 or 8. Play the pass line and odds bets. Maximize the latter.
-- $SIGNATURE
too many organizations publish them. MIL-STDs, NIST, other gov't orgs, IEEE, ACM, IETF, ISO, ANSI, and so on. And then there are legal standards like HIPAA. Internal corporate standards. Oh and lets not forget corporations who publish their own and then fail to meet them in their own product!
IMO, at some point they become so over bearing it becomes difficult to tell if the various standards are being met.
OK, that may not seem like a popular idea, but in the long run, it may be the best path to follow. While it could certainly be argued that there are too many "standards", the important thing is to become proficient with follow the "accepted" ones. You say you are reviewing different standards to help guide your career path. My best advice is to learn the basics, and learn them very well. Learn not only how they work, but how they work together. Yes, you will become more of a generalist, but you will also become proficient at determining how you can develop a solution by applying your knowledge that can best fit the given situation.
Focusing on a specific standard IS a crap shoot. Yes, you could make big bucks by jumping on the latest bandwagon, but it will no doubt be short-lived. Over the long haul, a broader knowledge base is more useful and marketable thatn a highly-focused one.
My mom always said, "Jim, you're 1 in a million." Given the current population, there are 7000 of me. God help us all!
The problem isn't with the quantity of standards, but the quality of specific ones. Standardization itself makes sense in a lot of cases, but sometimes standards are indeed made for the wrong reasons, or over-architected into oblivion (ie. SOAP + WSDL + UDDI + how many SOAP security standards) which makes the barrier to entry for compliance with those standards far too high to expect most people to bother.
Another problem is that a failure of some parties to properly adhere to the standards causes those standards to become less useful as well (read: MSIE vs. Mozilla, inconsistent HTML support, partial CSS support, JScript vs. JavaScript). This is sometimes even made possible by the standards themselves, by being too vague, which necessitates a level of "interpretation". It's also not always strategic for companies to follow standards -- they prevent lock-in, they make it easier to lose your customers to your competitors, and that can actually decrease the value of your products by giving your customers something to hold over your head during price negotiations. Standards need better incentives to get companies to actually buy into them, as opposed to just saying they are and then going and making their own "standards".
The other problem is that standardization, especially when the industry is in the middle of such a pro-standards push, often comes too early in the life of a given technology, resulting in a standard that doesn't account for the whole problem yet. For example, RSS was declared a standard before it was ever really adopted, and then some limitations were found in it that to fix would break backward compatibility. The result is a number of incompatible competing standards (RSS 1.0, RSS 2.0, RSS/RDF, Atom, etc.). SOAP and XML-RPC both did the same thing, and the result is that it's a pain in the ass for developers to support them, due to certain limitations in their designs (array support in SOAP, reflection as an afterthough in XML-RPC, etc.). SOAP and XML-RPC also resulted in a 3rd competitor as well, REST.
So my answer would be that there aren't too many standards, but that standards are just like anything else: not necessarily applicable to every situation. Use proper discretion. Neither extreme (all standards vs. no standards) is a good thing.
putfwd.com - 1GB Free file storage with a twist
I believe the problem arises when standards are written before being tested in the wild and without using time-tested techniques.
This was the problem with EJB. All these companies implemented the standard, but the standard that had never been tried before. Only now, are people realizing what a mistake it was.
With the various XML standards, time wasn't allowed to work out the flaws, and to allow various standards to merge. So, we have a bunch of standards and none of them are quit right.
Computing is a big field. Unless you narrow it down, nobody has a chance of answering the question correctly.
For example: writing web pages? There's one document standard (ISO-HTML), one client-side scripting standard (ECMA-262), one photo format standard (JPEG), one non-lossy graphics standard (PNG), and so on. (And before anybody disagrees, make sure you know the difference between a standard and a specification. XHTML and CSS are not standards). All these standards cover different areas, you can't simply eliminate one, so it's nonsensical to say that there are too many.
But if you are talking about a different field altogether, that paragraph is completely off-topic. There's no way to know unless you tell us. You might as well say "is the market too crowded?" without telling us which market you are on about.
How does a spec become a standard? People recognize the relative benefits of a spec versus the proprietary advantages of doing it their own way. Since standards tend to emerge in discrete verticals, there isn't a dilution of this benefit.
It would not be incorrect to say that a "standard" is really an honorific applied to the spec that won in the marketplace of ideas. If the discrete vertical you chose to be the "standard" in is trivial, then it will be a pyhric victory. If it is non-trivial, even if a better idea comes along, you will have a marked advantage as the "incumbent" standard. (QWERTY vs Dvorak keyboard layouts as an example). Eventually, if enough people see the benefit vs the advantage of the existing standard... new standard.
...But I digress. TREMBLE PUNY HUMANS!ONE DAY MY SPECIES WILL DESTROY YOU ALL!
Browers have been around a long time, and everybody's got one. For the past 3 years or so, I've demanded that my browser support tabbed browsing, control over popup windows, and preferably a useful download manager. Everything else is something I can do with or without or may be nice, but not a necessary feature.
/.ers and editors :) I also have on my Mac, Camino a native frontend to mozilla's gecko backend, and firefox and mozilla. All of these satisfy my needs.
On OSX, I use Safari with the KDE KHTML backend driving it. Its OK. One really cool, but unnecessary thing is that I can right click on any words in this dialog box and check the spelling for it, obviously not a desired feature for most
On Linux/Solaris and co, there's at least Galeon, Mozilla, and Konquerer. Oh, and every browser that I have mentioned is free.
So what is there to war about? Just surf the web with whatever you want, there's plenty of choices.
Three acronyms for ya:
CRLF
CR
LF
We have three major computer platforms, and three different standards for the line terminator in plaintext files.
Of course there are too many standards.
The sad thing about standards is that often the less good standards win. We saw this with the video tape format. And we see it with XML (which, believe it or not, is really not that good at all).
As long as you do the same, you should be ok.
perception is reality
rfc0001, called 1ml, which describes a standard way of doing everything possible, impossible, plausible or zany.
There are only as many [de-facto] standards as there are things that may require standardisation.
Your question is like asking:
"Hello fellow slashdotters, what a lovely day, I am here in my garden, and ooooh I am overwhelmed I saw, by all the lovely types of flowers. I think there are too many though, so should I try and plant all flowers, or flowers that grow well in this region, or flowers that are useful, or just flowers I am interested in? Oh my Carrot cake!"
Of course, this isn't entirely true, and baking carrot cakes does not fathom into it.
A standard called stmp isn't likely to garner much support for ftp type applications.
Of course, scp and other file transfer apps are related, but different.
Now, XML standards, don't call them standards, call them document types. You cut back on the number. [anything can be standard, you can say chairs are standard in an office, but that shouldn't worry you] Perhaps there are too many file format standards?
I think BMP, jpeg, jpeg 2000, gif, png, mng and tiff, iff and other formats all have thier own uses.
Apply this logic to your hetrogenous set of standards, and apply the following filter:
Am I interested in this standard, or is it useful for me? Yes / No
Have a good day.
#hostfile 0.0.0.0 primidi.com 0.0.0.0 www.primidi.com 0.0.0.0 radio.weblogs.com
No, next question.
[o]_O
Data remains.
:-)
I stick to my point of inherent redundancy in your question, but I do see what you are saying about companies jibing for a defacto standard that can garner them insutrial support.
Microsoft do this with thier monolithic and closed standards, but the world is changing.
I say that standards change, use them as tools, they are there to help. Don't make a career out of learning a standard that may become deprecated.
SVG is a good standard, with growing device and application support, and of course, not much interest to a network programmer.
Choose you area, and it comes equpit with its own set of standards, defacto and defunct
#hostfile 0.0.0.0 primidi.com 0.0.0.0 www.primidi.com 0.0.0.0 radio.weblogs.com
Never play the field, hard ways, or Big 6/8. Pass/Don't Pass taking the odds is the way to go.
Today, I went to the grocery store, looking for something sweet in the frozen foods section. The proliferation of ice cream varieties is astounding! Has humanity developed too many flavors?
I do agree that there are rather more ways of doing the same thing than you might expect, and compatibility between standards has (generally) been poor. Here are some examples. (The list is not intended to include everything.) You'll notice that a lot of the standards are extremely specific. There aren't many "general purpose" specifications out there, and those that exist (eg: SGML) tend to sacrifice fine control in favour of expansive capability.
(I'm not even going to try to document the few thousand IETF specifications and notices that exist. Of what is described by the IETF, how much is actually used in practice? Probably not a lot. Now, that's fine in that case, because the IETF is not writing these as press releases for products they're planning. It's much more a research and deveopment environment. In R&D, not everything works, but if you want to avoid repeating mistakes, you catalog those just as efficiently as your successes)
Authentication Systems:
Parallel Processing (running two or more processes in parallel, in such a manner that they can communicate with each other):
Library-based
Application-based
It's a small world and it smells funny; I'd buy another if it wasn't for the money; Take back what I paid (SoM)
As a developer, and in a word... No.
...Oh, and because IE is so much fun to break.
Standards are the scientific community's way of expressing the myriad ways of getting data (a thought, content, algorithm, etc.) out in a way that is most efficient for themselves. It will take agreement with others that that "standard" is recognizable as a means of transferring that cognitive substance. Given the level of agreement in the scientific community (commonly low), and the number of scientific classifications of endeavors (usually high), I would (IHMO) say no, the number of "standards" (or those systems of transference that are actually agreed upon from within the scientific community) do not number over any conceivable upper-bound.
From a commercial standpoint, having one "standard" (in any area of focus, to be sure) would be the Holy Grail, given you were the sole proprietor of the format or that format was innately "perfect" for carrying the data you wish to deliver. Standards always meet up with resistance at some point due to changes in methodologies or ideals. In today's world, there is a constant battle to outdate and outmode current standards in lieu of others that are more efficient and tailored to any specific class of problem wherein a transference of data is necessary, not because standards equate to clout, but because there is always a real need to revisit older standards for weaknesses.
Wups... Who said that?
Big 6/8 are sucker bets. If you must play them, ask the dealer for a place bet on 6/8 and you'll get better odds. Ceasar's isn't known for their craps odds, anyway. Just play don't pass and take out all the odds you can get (or pass, which is a little more traditional and the odds are almost as good).
Standards have the tendency to freeze innovation. For this reason, I like situations where there are competing standards since the friction between standards allows both room and reason for growth.
So, I guess I am not joking, I like worlds were people and companies are working to set their own standards and where we have a fair amount of leaway in our interpretation of implementation of standards.
Here is a JDBC-driven database access program that is free as in freedom and free as in beer.
How many "Ask Slashdot" news items can we have in a row?
Slow day in geek news?
http://brandonbloom.name
...and I repeat, Never bet on Big 6 or Big 8. They're sucker bets! Even more so than any other bet in Vegas
Everybody dies frustrated and sad and that is beautiful
Here's a great example.... I call you on the phone and you can hear me fine, we have a nice discussion. It's standard phone service, works great.
Next time I call you all you hear is me speaking gibberish. I am talking just fine but an intermediary has "embraced and extended" something that already works fine.
Then you hear the Microsoft rep on the line who says we have a decoder for this and it only costs $200 and breaks only 35% of the time
Sure there's a standard there, that's what Microsoft says but it worked already before they screwed with it.
i hate it when people play don't come bets. It's a sign of bad faith, and you are effectively betting against the table.
Part of the fun of craps is that everyone is on the same team
I think there might be.
I propose that we need a new standard - one that determines if other standards standard or not. I, of course, will write this standard, and for only 149.95 (that's mere pennies a day! Pennies, compared to almost universal wisdom!). I will benevolently bestow the list of all acceptable standards upon all who ask and can afford to continue to pay me.
I'm sure there are some people who might be worried I won't do a good job. Don't worry: I'm using the standard method of determining a standard method of determining which standards should be standard, so it's all good.
Mod me down and I will become more powerful than you can possibly imagine!
no matter what you say; we DON'T need more than one standard for measuring penises.
--- widget evolution: enhanced, plus, super, ultra, extreme, exxxtreme, ultra-extreme,
The reason Linux flounders like a wounded turkey instead of soaring like an eagle is LACK of standardization. Too many distros built according to the developers' particular prejudices. IBM created a standard and PCs took off. Standardize Linux and watch it grow.
Ignorance is curable, stupid is forever.
It's not so much that there are too many standards, the problem is too many junk standards.
Junk standards come in a variety of forms.
There's the 1000 page kitchen sink standards. Everything thrown together, no sane layering, policy and mechanism all mashed together, learning curve is a vertical line. Invariably, these lead to code that takes 2000 dense lines to say hello world.
Nebula standards. Often similar to the kitchen sink, but in spite of all the standardized options, too few are manditory. TIFF in the 80's tended to be like this. The only thing TIFF files seemed to have in common was starting with MM or II and being called TIFF. Odds were, only the program that wrote it could read it. The problem was that the readers and writers were all compliant, they just weren't interoperable.
All or nothing standards can be inappropriate in some cases. This is the opposite of the nebulous standard. They violate the principle of making common and simple things simple.
Patented standards. Too many standards bodies seem to be drinking the KoolAid by the truckloads. The real purpose of these standards is to make sure all roads lead to a royalty check for some company or another. Or, these days, to make sure the one serious threat to market dominance is legally barred from implementing at all.
Other issues really aren't because of the standards, but how they're (mis)used.
This includes html editors that produce a metric shitload of incomprehensible HTML gibberish to make sure that (God forbid) someone's browser doesn't present the page the way the user wants it to be presented rather than how it looks in the edit window.
Inappropriate standards worship is another issue. Raise your hand if you remember when CORBA was going to make absolutely everything interoperate in perfect peace and harmony forever, AMEN.
The problem isn't the proliferation of standards; it's the proliferation of non-standards.
Standards help us. They make us have to learn one thing, not ten or twenty. I mean, there's still lots of things to learn... But we can at least learn a given technology once.
My blog: http://www.seebs.net/log/ --- My iPhone/iPad app: http://www.seebs.net/seebsfrac/