They say that “diversity is the key of survival and evolution in any domain. In software world though, variations are so big that they have started to prevent cooperation between software users and developers.” Diversity is the key of survival and evolution in any domain. Because of variation, individuals from same species will react differently in the same environment, some surviving and becoming stronger, others disappearing. In software world though, variations are so big that they have started to prevent cooperation between software users and developers.
Note: Please note that the author is not a native English speaker, so please excuse any grammar mistakes.
Although
diversity in functionality is welcomed, assuring innovation and
evolution, applications should still have an uniform way of
interacting with the user to offer rapid understanding from new
comers. Unlike home user, which prefers a rich visual design, skins
and new ways to interact with the applications, business users
require a simple interface, clean, easy to use and similar to the
other applications which are already known by employees. They don’t
have time to admire new designs and figure out how to use them, and
want instead to fulfill their tasks as efficient as possible.
In
order to help these users, open source application developers
developed standards for graphical user interfaces (GUIs).
The standard for desktop applications, supported by companies such as
Sun Microsystems, Red Hat and Ximian
Novell, is GNOME Human Interface Guidelines
(HIG). This suggests methods for designing the GUI, like menu items
positioning and behavior for user actions.
Although
Linux “suffers” from a big variety of applications which fulfill
similar requirements, these started to use the same GUI standard,
assuring that any new user can take advantage rapidly of their
functionality. The ones which don’t follow GUI standards will be
abandoned in corporate desktop environment, where Linux starts to
gain market share.
The
majority of software applications work with data saved in files. The
diversity of file formats, many of them undocumented, make harder to
exchange documents between users from different environments.
Choosing an application depends now not only on it’s advantages, but
also on it’s presence in the environments one will be interacting
with.
As
it’s not beneficial and we can’t stop the existence of more
applications which have the same functionality, it’s necessary to
standardize the way these applications interact. Therefore, as the
computer is used in new domains, standards emerge which facilitate
the cooperation between users. We already know the standards which
allowed adoption and explosive growth of Internet, specifying a
common way of storing and exchanging information between different
platforms: HTML and TCP/IP.
Besides
the fact that these standards are open, meaning the data format and
method of using them are public, the implementation doesn’t require
using patents and paying fees. The W3C organization, responsible for
standards such as HTML and XML, proposed to allow standards which
require patented technology for implementation. Fortunately,
after critics from software industry, the proposal was refused and
we’ll continue to benefit from standards
whose implementation will be free for anybody.
Information
is becoming more diverse and new standards are needed to handle it,
existing ones being insufficient. Today, software users don’t change
only simple text documents, but also complex ones, images, sounds,
video.
The
biggest advantage of Microsoft in Office market is the use of its
formats to store documents. Besides these formats aren’t documented,
they change from version to version in order not only to force users
upgrading to new versions, but also to make it harder for other
applications to access Microsoft documents.
XML
[Extensible Markup Language] is a markup language for documents which
contain structured information. This information consists of content
(words, images, etc.) and indications for the role of the content.
Here is a sample XML document:
<addressbook>
<person>
<name>John Doe</name>
<phone>555-343434</phone>
</person>
</addressbook>
A
document like this can be read by any application which knows the
markup meaning, unlike a binary document, whose contents can be
accessed correctly only if it’s format it’s
also specified.
OpenOffice.org,
a suite of Office applications similar to the one offered by
Microsoft, uses a documented XML format to store files. This format
was proposed as standard by an OASIS (Organization for the
Advancement of Structured Information Standards) committee,
whose members include Sun
Microsystems, Corel and Boeing. The
committee will focus initially on
standardization for document formats and then will continue with
simplification of data exchange between any XML application and
Office. This includes automation of
business processes, web services, databases, search engines and other
applications.
In order to ease the exchange of information with complete integrity and to make sure you’ll be able to access a document after several years, I recommend to use an open format, such as OpenOffice.org, PDF or HTML.
We
can exchange simple images using the PNG (Portable Network Graphics)
open format, which keeps the quality of image intact and also has a
good compression. Being an open format, i.e.
documented and without patents, any application may export PNG images
and may take advantage of this functionality using free software
libraries. Other known formats, like BMP, JPEG, GIF, have problems
with big file size, loss of image quality or limiting of number of
colors. GIF was also covered by a patent which expired recently. The
Scalable Vector Graphics (SVG) format is open and can be used for
vectorial images.
But
what will you do if you’d like to exchange an image with layers?
You’ll use the default format of the graphic design application you
have, which is usually undocumented. Therefore you’ll work with Adobe
Photoshop or Corel Draw files, forcing your
partners to use the same software product. GIMP, an image
manipulation program similar to Adobe Photoshop, uses an open format
to store images, but there is no official standard. Proprietary
software producers don’t want to offer support
for open formats, as this will eliminate the dependency of their
application. Although it’s not done from their own initiative, they
will offer this support if a large percentage of users require it.
For
audio recordings there are now two efficient open formats, Ogg
Vorbis and FLAC. The first uses a technique
similar to MP3, eliminating sounds which can’t be heard by human
ear, and the second only compresses the files without any quality
loss. As it’s not necessary to pay a license fee to implement Ogg
Vorbis support, this is used increasingly in portable players, games
and broadcasting radio stations over the Internet.
Besides
the MPEG1 standards, you can make video recordings using the Theora
open format, which will compete with MPEG-4/DivX,
Real and Windows Media. This is not yet finished, but it nears the
completion.
Here
are some examples of other open standards which refer
to the way we send or access information:
-
Portable
Document Format (PDF) is an open format which keeps the integrity of
fonts, images and layout of any document, no matter the platform
it’s used on. Because of this property it became
the de facto standard for changing and archiving documents.World-wide
governments and companies adopted PDF for an efficient management of
documents, which raises the productivity and decreases
the dependency for paper, usually used to keep the documents intact.
OpenOffice.org 1.1 offers the possibility
to export any document as PDF, being the first free office
application allowing this on Microsoft Windows platforms.
-
Simple
Object Access Protocol (SOAP) is a protocol for exchanging
information in a decentralized and
distributed environment, being used
especially in web services. Google and
Amazon are examples of sites which offer public web services using
SOAP standard. You can use these services with already existing
applications and software libraries, without investing time in
implementing a new access method. -
Jabber
allows real-time exchange of messages between two users on a
network. The most used service of Jabber protocol is Instant
Messaging. Compared to other Instant Messaging systems (AIM, ICQ,
MSN, Yahoo), Jabber is open, extensible, decentralized and secure.
Anybody can run its own Jabber server, even with support for message
encrypting when confidentiality is a must. -
Structured
Query Language (SQL) offers a standard access to different
databases. With SQL you can develop and use applications which
require database access without depending on a specific database
server (Oracle, PostgreSQL, Microsoft,
etc.). More complex features, such as large binary objects or XML
queries, aren’t yet covered by this standard and their
implementation is different on every producer.
With
the help of open standards we are creating a business environment
where we can safely send documents without worrying if the contents
and layout will be exactly the same for the receiver. Proprietary
software producers try to stop this tendency, taking advantage of
users’s ignorance of standards, which creates
dependency for specific software products and reduces competition.
You
can also contribute to standardization by sending and requiring
documents in open formats. All applications listed below run and are
freely available as open source on Microsoft Windows, Linux, Mac OSX
and other platforms.
References
GNOME Human Interface Guidelines
http://developer.gnome.org/projects/gup/hig/
OpenOffice.org
http://www.openoffice.org
GIMP
http://www.gimp.org
Ogg Vorbis
http://www.vorbis.com
Theora
http://www.theora.org
Jabber
http://www.jabber.org
PostgreSQL
http://www.postgresql.org
About the author:
Software engineer, nature lover and free thinker, enlightened in 1997 by free software. He’s the founder of Galuna, a romanian provider of Linux-based IT solutions. He believes in freedom and art, spending his time working, discussing, listening to music and the sound of growing grass, contributing to the free software community, biking and contemplating beauties of the earth and universe.”
At least under Epiphany, your sample XML document doesn’t show correctly.
-Erwos
Shows well here under Epiphany-1.0.6
In order to help these users, open source application developers developed standards for graphical user interfaces (GUIs).
I notice that standards here is plural, why? Because the OSS community has no single standard for desktop enviroments, GUI toolkits, package managers, etc. But still after all this, they’re constantly bitching about standards.
How does the saying go? Before the OSS community points out the gnat in somebody else’s eye, perhaps they should deal with the camel in their own eye.
The sample XML doesn’t show up in Mozilla 1.3 either.
It works fine now. If it doesn’t, use another browser as it is probably the browser’s bug.
I notice that standards here is plural, why? Because the OSS community has no single standard for desktop enviroments, GUI toolkits, package managers, etc. But still after all this, they’re constantly bitching about standards.
There are standard desktop environments. KDE and GNOME.
There are standard GUI toolkits. GTK and QT
There are standard package managers. RPM, APT, Portage
The article mentions more open standards you are free to use.
Who’s bitching now?
The whole point of having a “standard” is to have ONE that is well documented and “free” to use in any way. You always mention two to three stuff on each category.
Who’s bitching now?
Note: Please note that the author is not a native English speaker, so please excuse any grammar mistakes.
English is my native language and I still can not write that well. 🙂 Darn public schools. Blam it on the chicago edu system.
The whole point of having a “standard” is to have ONE that is well documented and “free” to use in any way. You always mention two to three stuff on each category.
Experience teaches us there is no ONE right way of doing things. I don’t know which standard you refer to that is not well documented and free, in open source.
Only proprietary standards are licensed and closed as far as I know. And only proprietary standards enforce ONE and only ONE way of doing things.
Only proprietary standards are licensed and closed as far as I know. And only proprietary standards enforce ONE and only ONE way of doing things.
Duh, having only one way of doing things is what makes something a standard. Imagine if companies were to release CD players, each with their own standard. Who cares if they were open standards? I say it’s better to have one.
There are standard desktop environments. KDE and GNOME.
There are standard GUI toolkits. GTK and QT
There are standard package managers. RPM, APT, Portage
The article mentions more open standards you are free to use
I think you are mixing words here, because none of what you mention are actually standards.
A standard is not program, a toolkit, or a package manager. If they were, you could say that MS Word is a standard. (Well, it is a ‘defacto’ standard, but not a standard in the literal sense.)
I define a standard as some sort of RFC or other document that describes in detail how something should work, and then everyone builds products around that standard.
For example, a standard for package managers might be a document that explains (amoung other things) the xml (or whatever) file layout that package mangers would use to describe the packages that were install on a system, and then apt, RPM, etc could all use the same file format – THAT would be a standard. But this kind of thing where you build a toolkit, a DE, or whatever and calling it a standard is just wrong.
What you have instead is a bunch of free and open tools, not standards. And IMHO, that is what the OSS community really wants is for everything to be free and open … for companies like MS to create file formats and just hand it to them on a silver platter, so that they could create tools that would compete directly with MS. Yeah, that would make a lot of business sense for MS to do something like that.
While I agree that it would be fantabulous if every app and file format was open source, but we don’t live in a perfect world. And in the imperfect world we live in, there is room for both open and closed models. WIth some people who care mainly about money while others are more idealistic, there has to be room for both.
Really needs to do something in the standards department
It is lacking, it is needed it will solve of 90% of our hassles. For instance the stupid RPM fiasco has just got to stop.
RPM’s work it’s that there are two major problems with them IMHO.
1st – Binary compatibility needs to stop being broken after every major release with some distro’s.
2nd – Repositories need to be made and kept updated with the latest software.
For free distro’s RPM’s can be made to work seamlessly with installation tools like Open Carpet, urpmi, or APT/Synaptic. The problem lays with commercial distro’s that constantly change things around as to break RPM compatibility within their own RPM package format. Not to mention the hassle of either waiting for updates to repositories or finding a new repository for packages with these commercial distros. Again with free distro’s RPM’s can be made to work and work well as a delivery method for applications. There are both command line and gui tools out there that more then meet the needs and specifications to deal with the dependency problems that one faces with the manual installation of rpm’s. It’s just that repositories need to be kept updated and binary compatibility needs to be foremost in the minds of distro makers, especially commercial ones. In fact I’d say that RPM is one standard that does work it’s just that people/distro makers screw up in the execution of delivery of RPM’s to their end-users in most cases.
While I agree that it would be fantabulous if every app and file format was open source, but we don’t live in a perfect world. And in the imperfect world we live in, there is room for both open and closed models. WIth some people who care mainly about money while others are more idealistic, there has to be room for both.
Open source != Open standard #OK.
I assume you are not a programmer, so I will give an example that you can understand. Image, you brought and ford tarus and one day your tires go flat. you write down the measurement of the tire (70/175 D 28 3/9) and go down to your local tire shop to have it replace. All you see are 175/70 R 14, 175/70 R 15, etc… You find out ford tarus uses non-standard tires and the only way to replace them is through your local ford dealer (lock in).
Lucky the auto industry uses standard parts so the next time you or I have a flat, thank God we have open standards.
Some things I don’t quite agree with:
“Unlike home user, which prefers a rich visual design, skins and new ways to interact with the applications, business users require a simple interface, clean, easy to use and similar to the other applications which are already known by employees. They don’t have time to admire new designs and figure out how to use them, and want instead to fulfill their tasks as efficient as possible.”
This is a myth. The home user IS the business user. These aren’t two classes of people, they are one and the same. Business users don’t just disappear into thin air after they leave the office at 5 pm. They go home and become “home-users”. They both use the same applications: email, reading and writing documents (using MS Office) and browsing web.
At the office there might be a few company specific applications that have no use in the home environment but that’s it.
Also: “The user” doesn’t prefer to skins and doesn’t prefer rich visual design. Why not? Because he/she only knows Windows. The same OS used both at home and in the office. The user (since we are generalizing
) doesn’t use skins because he/she doesn’t know they exist (the usefulness of skins themselves is another discussion).
As for some of the standards mentioned: it is always nice to hope for the best (don’t we all?), but reality is usually different.
PNG isn’t widely used, despite being around for some years already.
JPEG and BMP are the standards people use.
SVG is the same. No user-base of any real magnitude, eventhough it had a lot of support from Adobe from the outset.
Theora I’m sure is a nice project, but for all its it has no chance of competing with MPEG4 and other established formats.
And don’t forget that however nice PDF documents are for interchange, they cannot be edited in any meaningful way (yes I know about the “edit” features the viewer has. They don’t cut it as PDF does not retain the document flow).
Overall, not a bad article, but it could have used a tad more realism.
There is a large debate at the moment about POSIX v Linux Standards Base (LSB). The LSB folks have effectively developed a competing standard, for which there is specific technical justification. LSB is being standardised by ISO. This is just a waste of time as POSIX is already well established, covers the subject matter, and so on. So in this case, LSB folks look like they pulling a microsft / proprietary stunt: using the sheer following of Linux to push through a standard that doesn’t need to be there. It would be far more effective if LSB worked with POSIX for a common outcome. The entire industry (including Linux) would win.
Duh, having only one way of doing things is what makes something a standard. Imagine if companies were to release CD players, each with their own standard. Who cares if they were open standards? I say it’s better to have one.
Not exactly. Standards exist to guide you not to command you. Take a look at how many standard programming languages there are. Going by your logic, we should just write code in ONE language.
I think you are mixing words here, because none of what you mention are actually standards.
They are well known. They are popular. They are used by majority of entities including large corporations. They are supported by major if not all vendors. They are accepted among the community as criteria for measuring compatibility, integration and usage. These make them standards to me. I’m not mixing words, you are reading too much into the meaning of a standard.
A standard is not program, a toolkit, or a package manager. If they were, you could say that MS Word is a standard. (Well, it is a ‘defacto’ standard, but not a standard in the literal sense.)
Aren’t you contradicting yourself here. MS Word is a standard but it’s not a standard? Besides, you brought up toolkits, package manager and DEs, not me.
I define a standard as some sort of RFC or other document that describes in detail how something should work, and then everyone builds products around that standard.
While your definition is theoretically sound, in practice a standard in anything that widely accepted and agreed upon by a community of users. There are thousands of RFCs that would never see the light of the day. Only the popular, widely used and widely accepted RFCs *might* become standards.
Your theories are fascinating but we live in the real world.
For example, a standard for package managers might be a document that explains (amoung other things) the xml (or whatever) file layout that package mangers would use to describe the packages that were install on a system, and then apt, RPM, etc could all use the same file format – THAT would be a standard. But this kind of thing where you build a toolkit, a DE, or whatever and calling it a standard is just wrong.
Oh, yes. Exactly my point. There are such standard. *nix developers know /etc, should contain configuration files, /lib should contain libraries, /bin should contain executable binaries, /home is reserved for users and so on.
If I’m not mistaken the LSB is responsible for such framework. Most *standard* package managers adhere partially to them. Many of the LSB policies are not popular because many people don’t like their restriction. e.g RPMs being the defacto package manager and so on. A revision of some of these policies needs to be considered if they are to be taken seriously. Otherwise some of the LSB policies will be one of those thousands of RFCs that failed to gain popularity and failed to become standards.
Needless to say, their are standards, and they are being followed.
What you have instead is a bunch of free and open tools, not standards. And IMHO, that is what the OSS community really wants is for everything to be free and open … for companies like MS to create file formats and just hand it to them on a silver platter, so that they could create tools that would compete directly with MS. Yeah, that would make a lot of business sense for MS to do something like that.
Then don’t bitch when you can’t open a word document in anything but MSOffice.
While I agree that it would be fantabulous if every app and file format was open source, but we don’t live in a perfect world. And in the imperfect world we live in, there is room for both open and closed models. WIth some people who care mainly about money while others are more idealistic, there has to be room for both.
Home users, educational institutions, charitable organisations, corporate entities, you and I will benefit the most if open standards are pushed and adopted. Open standards means anyone and everyone can compete on open and fair grounds. Open standards, doesn’t mean having ONE toolkit, ONE desktop env, ONE package manager, ONE browser or ONE way of doing things.
There could be multiple ways of doing things. And as long as their open and free, those ways of doing things can work well together. User benefit in the end. Standards change with time, they are not static. And standards should never force users into doing things in only ONE way.
It doesn’t matter what “standards” the world uses. It’s true that BMP and JPeg are the most popular picture formats, but the open source community needs to push open formats rather than settling for what everyone else is using. When someone starts using Linux (or any OS-O/S), they expect everything to be Free in all senses of the word. Also, the speed at which OS programs and technologies improve is reason enough to stand behind them. If they aren’t the best of breed yet, they will be soon.
The image file types are trivial anyway, since open and closed programs support most formats under the sun.
I’m a bit suprised the writer mentioned FLACK and not Xvid, I haven’t used Flack yet, but Xvid has been around for awhile and has similar performance to Divx.
Not FLAC, Theora.
The point with LSB, is simply that it is an extension to POSIX for the most part.
Having an LSB-compliant Linux distro doesn’t mean that my Kernel threading is not POSIX compliant.
There are some areas of POSIX which, in hindsight, are not perfect. There are some which suit large scale old Unices, but are unsuitable for the direction of Linux, and that is alright too.
LSB can be seen as taking the best bits of POSIX and fixing most of the worse bits.
The old RPM debate can carry on ad nauseum, but to be frank, it needed to mention packaging in some way, and modern RPM implementations are satisfactory.
It looks like we can’t agree on what a standard is. How can we define any standards without deciding on the definition of a “standard”? This seems to me to be the first order of business here.
We wouldn’t want to make any standards, then Linux would be easier to use, and then we couldn’t have our secret handshake club anymore.
“LSB can be seen as taking the best bits of POSIX and fixing most of the worse bits. ”
Isn’t that like saying unix was wrong?
Read the current debates on POSIX mailing lists. It is clear that POSIX folk are open and willing to adapt and work with LSB, on the other hand, LSB seem to maintain a more arrogant attitude that they need to be different.
Standards are about a bit of give and take, some imperfection (especially trying to maintain a consistent standard for so many years, etc). Just think of all the inconsistency that POSIX had to deal with when it first harmonised vendor proprietary standards.
It’s just depressing: LSB will standardise, then there will be these niggling portability differences.
10 years ago, it was: #if __SYSV__ #elif __BSD__
In 5 years it will be: #if __POSIX__ #elif __LSB__
That just sucks. Now is time to prevent it from happening. Yet the Linux folk are doing exactly what the Microsoft folk are doing: we’re bigger and more powerful, we can do it our way, tough luck.
This is not what the spirit of Linux and Open Source is about.
OGG Theora and XVid are not exactly interchangable. OGG Theora will have features which are impossible with XVid. One i’m aware of, which is why i’ll use OGG Theora, is that OGG Theora can be used for live streaming of video over the internet – essentially being an alternative for the proprietary, closed-source RealPlayer.
Not exactly. Standards exist to guide you not to command you. Take a look at how many standard programming languages there are. Going by your logic, we should just write code in ONE language.
As I see it, standards are there to command you, in order to make sure that everybody is compatible with everybody else. By your logic, if standards were only there to guide you, the docs would say something like: “Well, this is a standard, but if you don’t like it, just do your own thing. You may not be compatible with those who follow the standard, but choice is good …”
While your definition is theoretically sound, in practice a standard in anything that widely accepted and agreed upon by a community of users.
Alright, so how many people (or percentage of people) have to use it before something is considered a standard ? If I build an app and 10 people use it, is it then a standard?
Home users, educational institutions, charitable organisations, corporate entities, you and I will benefit the most if open standards are pushed and adopted. Open standards means anyone and everyone can compete on open and fair grounds.
There could be multiple ways of doing things. And as long as their open and free, those ways of doing things can work well together.
True, but having open standards (and I use the term ‘standards’ loosely here) does not benefit greedy big businesses who want the playground all to themselves. And since this is the only group that really matters, it makes no difference whatsoever whether end users benfit or not. End users aren’t the ones with all the money so in the grand scheme of things, they’re really not all that important, as long as they keep feeding the corporate machine.
… of success of standards, look no further than GSM.
Europe got its act together to agree on one mobile telephony standard – so now Europe has a phenomenal market, high degree of penetration, seamless roaming across multiple countries, large diversity of handsets and equipment, and so on. Contrast to the United States.
… of failure of standards, look no further than writable DVDs.
Multiple manufacturers couldn’t agree – releasing numerous writable standards rather than agreeing on one: confusing the market. In the UK, the consumers association last year prior to Christmas warned consumers of the danger of these incompatible and possibly short-to-live standards, and berated the industry for causing the problem.
Are you kidding me, cell phones here more expensive than in the USA where practically give you the phone for free, same goes for call prices. Just compare the prices on amazon.com to those on amazon.co.ok.
Just compare the quality of phones and features though. What you get for the US non-GSM market is crap. It’s little wonder they are giving them away to attract customers – and pricing the services higher as a result. Take a look at the whole picture dude.