Slashdot Mirror
GNOME 1.2 - What's In It For You?
Ur@eus writes: "We have just posted an article at Linuxpower.org desribing what's new in the GNOME 1.2 release. Since the GNOME press release was kinda thin I think this will be of interest to many people. You'll find the article here. " A nice overview, for non-Gnomers especially. You'll find even more beautiful screenshots, as well as more general information, on the Helixcode site.
The general tone of the comments here makes me want to weep - I can not believe the amount of bitching.
/. moderators would know not to moderate that kind of post up.
There are a few points of FUD always bandied about in these discussions.
1) GNOME is unstable.
This is wrong, plain and simple. 1.0 was released too early, and gave people a bad impression. Does the fact that GNOME was unstable make it unstable now? No!
2) GNOME is a hack.
People generally say this because they can not understand OO in C. If you like C++, fine, use it.
Use one of the GTK C++ bindings, eg gtk--.
The GTK+ object system is more flexible due to its dynamic nature, and it is (in my experience) easier to know what is going on - no pointer assignments doing copies remotely over CORBA, due to the fun of operator overloading.
3) Its all an RMS conspiracy against KDE.
This is the "Debian hates KDE!" type stuff.
The fact is that it is a breach of the licence to distribute KDE in binary form right now, as they still don't seem to have made up their minds on what to do (Artistic Licence, GPL exception).
This will be fixed I'm sure.
There are a lot of other stupid things people say,
but by now I would hope
Part of the services that Helix provide for the packages we ship is
the updating service: this is a service that lets people deploy
fixes, improvements, and new GNOME packages in their system with a
simple to use user interface.
Currently our updating service works with RPM and Debian packages
(In Debian we just use the great apt infrastructure to achieve
this), but other platforms do not have very sophisticated packaging
systems that support upgrading and that support vendor tagging.
Building software with RPM is very good, as we can keep the
original source packages plus all the patches required as well as
the detailed instruction list of how the package was build in a
single location (the Source RPM).
This is what we used to do the Solaris port of Helix GNOME. And
naturally, RPM produced RPM packages, which we could easily
integrate into our updating service.
Using Solaris packages would be an option, but by the time we were
done with the packages, it was too late on the release cycle to add
support for Solaris packages (not to mention that Solaris packages
are not as powerful as RPM packages).
Hence, we decided that it was in the best interest of end users to
use and distribute RPM packages for this release in Solaris. This
might change in the future though.
Please describe what is functionally different between:
struct widget_s {
void(*open)(struct widget_s*);
void(*close)(struct widget_s*);
};
and:
class widget {
void open(void);
void close(void);
};
This "you can't do OO in plain C" attitude is silly and immature. Anyone who has done any work on a large (>100,000 line) C project has probably run into OO methodologies employed within the program. Heck, you can do OO in assembly if you have a good design and structure your code properly.
On the other hand, I've seen plenty of C++ code that was far from object-oriented--inelegant, over-classed, and buggy C++ code. No matter what language you use, you can program it wisely or poorly, elegantly or hacked together.