noor - نور » linux http://noor.ojuba.org Kefah Issa weblog - مدونة كفاح عيسى Thu, 17 Dec 2009 07:52:24 +0000 http://wordpress.org/?v=2.8.6 en hourly 1 QT for GNOME http://noor.ojuba.org/2008/07/qt-for-gnome/ http://noor.ojuba.org/2008/07/qt-for-gnome/#comments Tue, 15 Jul 2008 21:23:34 +0000 Kefah Issa http://noor.ojuba.org/?p=18 I feel very strongly about the historical opportunity for the GNOME community to switch their tool kit over to QT 4.x. GNOME was originally a fork of effort from KDE back in the old days when QT was not GPL-enabled.

Now it is — and so for many years — I can see no reason why GNOME can’t do the switch.

This will be a major effort of course, and there will be two types of opponents in the GNOME community :
A. C-Lovers : Those who like C-language (not C++) as GTK and GNOME in general is more C-Lang than C++.
B. Mono-lovers : Those who are after mono, which is not a very successful imitation for Microsot .NET.

Lets put that a side for a minute and lets give it a hard look, GNOME development has been stalled due to many technology limitation. Even with the latest GUADEC and talk about tab-enabling (which i still think is a joke).

So, despite our love and hate, at the end of the day QT is THE most mature toolkit in the FLOSS world. It deserves all the blessings it can get … and very well deserves to be considered as an excellent candidate for the GNOME project, especially after what happened with KDE4 and their move into directions that are far from the users and community. The failure in KDE4 was a result of the people who assumed its leader ship in the last two years, and its not in any way related to QT.

]]> http://noor.ojuba.org/2008/07/qt-for-gnome/feed/ 0 The wars are over, let the era of peace and prosperty begin! http://noor.ojuba.org/2008/07/the-wars-are-over-let-the-era-of-peace-and-prosperty-begin/ http://noor.ojuba.org/2008/07/the-wars-are-over-let-the-era-of-peace-and-prosperty-begin/#comments Sat, 05 Jul 2008 08:50:08 +0000 Kefah Issa http://noor.ojuba.org/?p=13 In the computer industry, the pendulum of debate, innovation, and building infrastructure at one end vs building up complete and ready solutions on the other end keeps swinging every 20 years (more or less).

So here it comes, to the rest of the thinkers and planners and to the delight of the builders and engineers; the era of FLOSS

In this blog, I might sound biased or short-sighted. Its really just an opinion based on my day to day findings. Please don’t be harsh on me, if you want to comment, take me completely out of the picture and focus on the ideas and let them debate in a professional fashion.


In the beginning there was the operating system

In my professional view, GNU/Linux (and FLOSS) is the clear winner (over MacOs and Windows) …
GNU/Linux is not a prospect, or a great idea any more. its a solid fact on the ground. that is being used millions of people in mission critical systems addressing real life needs, both at home and at work. with an ever increasing adoption rate, the whole FLOSS era has certainly passed its childhood as being opted by hopiests and enthusiasts into being used in real life by real people wither individuals or organizations.

In a very ironic and unexpected fashion, Windows Vista is a great failure. It took too long to come up with, and when it came it was a disaster on two important aspects : performance, hence requiring considerably more hardware power to run, and stability.

This very incident is what probably gave GNU/Linux the time to get a head of Windows.

On the server-side

The FLOSS has the lead in adoption and innovation, this wasn’t the case few years ago.

Java et al has become fully open source; Groovy and Grails is second to none when it comes to agile web-development, Ruby on Rails started the new era of web 2.0 and RAD web development, Php is the people’s scripting language, Apache is the leading web server, MySQL and PostgreSQL have the full horse power to compete with the big boys and so forth.

The road a head is so clear to the point where there is no need to make any case for FLOSS on the server side. FLOSS offers a wide variety of options covering most of today’s needs.
No need for me, as a technology consultant, to ever think twice about choosing FLOSS vs Proprietary.

What about Open Solaris? That will surely continue to be the big brother covering up for GNU/Linux for even more critical situation. The relation between Open Solaris and GNU/Linux is not a competition, its rather complementary.

On the desktop/client-side

Within GNU/Linux there has been another war, the War of the Desktop Environments (DE) and the war of toolkits …
On the Desktop Environment side, I believe its time to declare that there has been no winner! :(
Not KDE nor GNOME.
KDE went into a very unpleasant direction with KDE4, its becoming more like the fantasy of its developers as opposed to being practical and usable. With the huge effort and long time (2years plus now) put on those fantasies as opposed to just upgrading its core tool kit from Qt 3.x to Qt 4.x means its not expected that KDE4 steers back to doing just that. KDE 3.x series was the best ever released Desktop environment on Linux platform.
GNOME has caught the infection, actually even before KDE 4 started. With the completely unjustified adoration to Microsoft … comes the Mono project. Which is – with all respect to the hard working people who made it happen – a shame. Most of the FLOSS working class who create software have realized that following on the heels of someone else is a never ending story, and will get us no where. FLOSS project leaders need to have independent thinking and a clear vision. Let alone the ugly heaviness of the Mono project and its apps, compared to plain gtk.

For my day to day use, I am relying on XFCE is my DE of choice, as it covers all my needs, and does a great job in letting me focus on the apps rather than DE. ( I used to be a die-hard KDE users for the past seven years)

XFCE is so close to becoming a winner and surpassing KDE and GNOME with bounds and leaps, when it comes to simplicity,  and performance.

One important good thing that has been going on for the last few years, is freedesktop.org doing a great job in standardizing the desktop operation regardless of the running environment. All distros have also adopted dbus as their core inter-process communication engine.
Minimizing the importance the importance of KDE or GNOME and maximizing the importance of standardization. This is why XFCE was able to fit so easily.

Back to the basics, XFCE (or the like of a lightweight DE) along with Gtk/Qt only apps seem to be the natural direction. Given the fact that Gtk and Qt app run on the other platforms without much of a hassle. Application developer from the two camps (kde and gnome) need now to steer away from DE and back into being Toolkit centric; or at least offer that option.

Both Qt and Gtk only apps are fast and snappy and don’t require lots of depdency. Unlike DE Apps, which would require the whole underlying libraries and subsystems of the respective DE.

If I like konqueror why should I live with the kde dinosaur?!

As with the Gtk case, more and more Qt-only apps are showing (e.g. Speedcrunch, Aurora), some KDE apps are also supporting Qt-only mode (kchmviewer).

I tried those types of apps on GNOME or XFCE only environment and they are a breeze to run. No performance overhead, despite the fact they need to load Qt libraries, but this happens only once and doesn’t eat much memory.

In the debate between Qt and Gtk, and despite all the nice things Gtk offers. Qt is the clear winner.
Qt 4.4 is becoming the jewel of the crown in the FLOSS world, Qt 4.5 is expected to shine even more.

Last but not least, Qt being GPL’ed on all platforms eliminates the last obstacle of adoption. Remember, this was the very reason why GNOME started off from KDE.

I predict that Qt Apps will have a huge edge, presenting cross-platform open-source alternatives, every overtaking existing big names such as firefox and Openoffice.

  • Web-kit based Web browser
  • Phonon based player
  • Office suite that natively supports ODF
  • Simplified Desktop environment that is xfce-like, that runs on all platforms
  • … and so forth

The very notion of becoming cross-platform is really important and intriguing; no more do you as an application developer limit your user with their choice of platform. hence giving your app a far wider base of audience.
Look at what OpenOffice and Firefox did. They are almost every where.

Same token applies on embedded systems, wither mobiles, sub-notebooks, modems and routers, media centres and so forth.

Conclusion

The important and strategic point to bear in mind is the peace of mind and durability of the software. All FLOSS software is being built to live far longer than its counter part. No fear of vendor locking or platform dying out. Being cross platform means both developers and users will feel better.

This year, 2008, FLOSS community has completed laying down the technology foundations for many years to come. The pillars and infrastructure is there, its now the time to reap the advantage and develop even more mature applications.

Investing in learning those technologies is a guaranteed one, and could only mean having the advantage.

That shift of mentality and focus is needed to make the next wave of change.

Does that mean innovation on those areas has reached its limit? no. but it means the pendulum is now shifting to building up applications as the infrastructure and its related thinking process is completed.

The road for the next years is clear for FLOSS to become the leader in the computer software industry. I am very optimistic on where FLOSS stands now and where its heading, having great confident that the best is yet to come.

]]> http://noor.ojuba.org/2008/07/the-wars-are-over-let-the-era-of-peace-and-prosperty-begin/feed/ 0 GEdit with Groovy http://noor.ojuba.org/2008/06/gedit-with-groovy/ http://noor.ojuba.org/2008/06/gedit-with-groovy/#comments Sat, 14 Jun 2008 07:22:26 +0000 Kefah Issa http://ojuba.org/kefahblog/?p=8 Need a cool development setup for Groovy and Grails on Linux?

No I don’t mean Eclipse nor IntelliJ, and Yes, I’m smart enough for that I’m dumping the autocompletion and autoerror detection; at least I know i’m smarter than the current plugins for those two. :)

Searching for a good development setup for my groovy and grails projects, i tried IntelliJ and Eclipse along with their groovy and grails plugins. I wasn’t impressed, more so because they fail to properly understand things and give you errors where there are none.

So, I eneded up using GEdit which is a very nice piece of software. I whished Geany had groovy syntax highlight support, but it doesn’t, further more, Geany doesn’t do a good job when dealing with Arabic text inside the code; while GEdit has a fairly good support for arabic.

GEdit doesn’t come with groovy support out of the box, after a short search I found this article :
http://www.sudovi.com/blog/show/teach_gedit_grails
That worked for me.

Here is how it looks like :

Grails and GEdit
I then compiled all the steps needed to enable groovy on gedit in one handy bashscript file for Fedora 9:

 
cat > groovy-gsp-mime.xml << EOF
<?xml version="1.0" encoding="UTF-8"?>
<mime-info xmlns="http://www.freedesktop.org/standards/shared-mime-info">
 
	<mime-type type="text/x-groovy">
		<sub-class-of type="text/x-java"/>
		<comment>Groovy Source File</comment>
		<glob pattern="*.groovy"/>
	</mime-type>
 
	<mime-type type="text/x-gsp">
		<sub-class-of type="text/html"/>
		<comment>Grails GSP File</comment>
		<glob pattern="*.gsp"/>
	</mime-type>
 
</mime-info>
EOF
 
cat > groovy.lang << EOF
<?xml version="1.0" encoding="UTF-8"?>
<language id="groovy" _name="Groovy" version="2.0" _section="Sources">
  <metadata>
    <property name="mimetypes">text/x-groovy</property>
    <property name="globs">*.groovy</property>
    <property name="line-comment-start">//</property>
    <property name="block-comment-start">/*</property>
    <property name="block-comment-end">*/</property>
  </metadata>
 
  <styles>
    <style id="comment" _name="Comment" map-to="def:comment"/>
    <style id="error" _name="Error" map-to="def:error"/>
    <style id="string" _name="String" map-to="def:string"/>
    <style id="external" _name="External" map-to="def:preprocessor"/>
    <style id="declaration" _name="Declaration" map-to="def:type"/>
    <style id="storage-class" _name="Storage Class" map-to="def:type"/>
    <style id="scope-declaration" _name="Scope Declaration" map-to="def:type"/>
    <style id="keyword" _name="Keyword" map-to="def:keyword"/>
    <style id="null-value" _name="Null Value" map-to="def:special-constant"/>
    <style id="boolean" _name="Boolean value" map-to="def:boolean"/>
    <style id="number" _name="Number" map-to="def:decimal"/>
    <style id="reserved" _name="Future Reserved Keywords" map-to="def:error"/>
    <style id="type" _name="Data Type" map-to="def:type"/>
  </styles>
 
  <definitions>
 
    <context id="string" style-ref="string" end-at-line-end="true">
      <start>"</start>
      <end>"</end>
    </context>
 
    <context id="string-2" style-ref="string" end-at-line-end="true">
      <start>'</start>
      <end>'</end>
    </context>
 
    <context id="line-comment" style-ref="comment" end-at-line-end="true">
      <start>//</start>
      <include>
        <context ref="def:in-line-comment"/>
      </include>
    </context>
 
    <context id="block-comment" style-ref="comment">
      <start>/*</start>
      <end>*/</end>
      <include>
        <context ref="def:in-comment"/>
      </include>
    </context>
 
    <context id="close-comment-outside-comment" style-ref="error">
      <match>*/(?!*)</match>
    </context>
 
    <context id="externals" style-ref="external">
      <keyword>import</keyword>
      <keyword>package</keyword>
    </context>
 
    <context id="declarations" style-ref="declaration">
      <keyword>class</keyword>
      <keyword>enum</keyword>
      <keyword>extends</keyword>
      <keyword>implements</keyword>
      <keyword>instanceof</keyword>
      <keyword>interface</keyword>
      <keyword>native</keyword>
      <keyword>throws</keyword>
    </context>
 
    <context id="primitive-types" style-ref="type">
      <keyword>boolean</keyword>
      <keyword>byte</keyword>
      <keyword>char</keyword>
      <keyword>def</keyword>
      <keyword>double</keyword>
      <keyword>float</keyword>
      <keyword>int</keyword>
      <keyword>long</keyword>
      <keyword>short</keyword>
      <keyword>void</keyword>
    </context>
 
    <context id="storage-class" style-ref="storage-class">
      <keyword>abstract</keyword>
      <keyword>final</keyword>
      <keyword>static</keyword>
      <keyword>strictfp</keyword>
      <keyword>synchronized</keyword>
      <keyword>transient</keyword>
      <keyword>volatile</keyword>
    </context>
 
    <context id="scope-declarations" style-ref="scope-declaration">
      <keyword>private</keyword>
      <keyword>protected</keyword>
      <keyword>public</keyword>
    </context>
 
    <context id="flow" style-ref="keyword">
      <keyword>assert</keyword>
      <keyword>break</keyword>
      <keyword>case</keyword>
      <keyword>catch</keyword>
      <keyword>continue</keyword>
      <keyword>default</keyword>
      <keyword>do</keyword>
      <keyword>each</keyword>
      <keyword>else</keyword>
      <keyword>finally</keyword>
      <keyword>for</keyword>
      <keyword>if</keyword>
      <keyword>render</keyword>
      <keyword>return</keyword>
      <keyword>throw</keyword>
      <keyword>switch</keyword>
      <keyword>try</keyword>
      <keyword>while</keyword>
      <keyword>with</keyword>
    </context>
 
    <context id="memory" style-ref="keyword">
      <keyword>new</keyword>
      <keyword>super</keyword>
      <keyword>this</keyword>
    </context>
 
    <context id="future-reserved-words" style-ref="reserved">
      <keyword>const</keyword>
      <keyword>goto</keyword>
    </context>
 
    <context id="null-value" style-ref="null-value">
      <keyword>null</keyword>
    </context>
 
    <context id="boolean" style-ref="boolean">
      <keyword>false</keyword>
      <keyword>true</keyword>
    </context>
 
    <context id="numeric" style-ref="number">
      <match extended="true">
        (b([0-9]+|0[xX][0-9a-fA-F]+)[Ll]?b|
         b(([0-9]+[Ee][-]?[0-9]+|
            ([0-9]*.[0-9]+|[0-9]+.)([Ee][-]?[0-9]+)?)[fFdD]?|
            [0-9]+[FfDd]))
      </match>
    </context>
 
    <context id="groovy">
      <include>
        <context ref="string"/>
        <context ref="string-2"/>
        <context ref="line-comment"/>
        <context ref="block-comment"/>
        <context ref="close-comment-outside-comment"/>
        <context ref="externals"/>
        <context ref="declarations"/>
        <context ref="primitive-types"/>
        <context ref="storage-class"/>
        <context ref="scope-declarations"/>
        <context ref="flow"/>
        <context ref="memory"/>
        <context ref="future-reserved-words"/>
        <context ref="null-value"/>
        <context ref="boolean"/>
        <context ref="numeric"/>
      </include>
    </context>
 
  </definitions>
</language>
EOF
 
cat > gsp.lang << EOF
<?xml version="1.0" encoding="UTF-8"?>
<language id="gsp" _name="GSP" version="2.0" _section="Markup">
    <metadata>
      <property name="mimetypes">text/x-gsp</property>
      <property name="globs">*.gsp</property>
      <property name="block-comment-start">&lt;!--</property>
      <property name="block-comment-end">--&gt;</property>
    </metadata>
 
    <styles>
        <style id="comment" _name="Comment" map-to="xml:comment"/>
        <style id="tag" _name="Tag" map-to="xml:element-name"/>
        <style id="attrib-name" _name="Attribute Name" map-to="xml:attribute-name"/>
        <style id="attrib-value" _name="Attribute Value" map-to="xml:attribute-value"/>
        <style id="dtd" _name="DTD" map-to="xml:doctype"/>
        <style id="error" _name="Error" map-to="xml:error"/>
    </styles>
 
    <default-regex-options case-sensitive="false"/>
 
    <definitions>
        <!-- Html comments are more permissive than xml comments -->
        <context id="comment" style-ref="comment">
            <start>&lt;!--</start>
            <end>--s*&gt;</end>
            <include>
                <context ref="def:in-comment"/>
            </include>
        </context>
 
        <context id="dtd" style-ref="dtd">
            <start>&lt;!</start>
            <end>&gt;</end>
        </context>
 
        <!-- This is a placeholder context intended to be <replace>d
             in languages like php that need to embedd contexts inside
             html tags and attributes.
        -->
        <context id="embedded-lang-hook">
            <start>%{def:never-match}</start>
            <end></end>
        </context>
 
        <context id="generic-tag">
            <include>
 
                <!-- Attribute in the form: name="value" -->
                <context id="attrib-quoted" style-ref="attrib-name">
                    <start extended="true">
                        [A-Za-z0-9:_-]+ # attribute name
                        s*=s*         # "="
                        (")            # string beginning
                    </start>
                    <end>"</end>
                    <include>
                        <context sub-pattern="1" where="start" style-ref="attrib-value"/>
                        <context sub-pattern="0" where="end" style-ref="attrib-value"/>
                        <context id="string" extend-parent="false" end-at-line-end="true" style-ref="attrib-value">
                            <start>%{def:always-match}</start>
                            <include>
                                <context ref="xml:entity"/>
                                <context ref="xml:character-reference"/>
                                <context ref="embedded-lang-hook"/>
                            </include>
                        </context>
                    </include>
                </context>
 
                <!-- Attribute in the form: name=value -->
                <context id="attrib-unquoted" style-ref="attrib-value">
                    <start extended="true">
                        [a-z0-9:_-]+ # attribute name
                        s*=s*      # "="
                    </start>
                    <end>(?=&gt;|s)</end>
                    <include>
                        <context sub-pattern="0" where="start" style-ref="attrib-name"/>
                        <context ref="xml:entity"/>
                        <context ref="xml:character-reference"/>
                    </include>
                </context>
 
                <!-- Attribute in the form: name -->
                <context id="attrib-no-value" style-ref="attrib-name">
                    <match extended="true">
                        [a-z0-9:_-]+  # attribute name
                    </match>
                </context>
 
                <context ref="embedded-lang-hook"/>
 
            </include>
        </context>
 
        <context id="script">
            <start>&lt;s*script%]</start>
            <end>&lt;s*/s*scripts*&gt;</end>
 
            <include>
                <context sub-pattern="0" where="start" style-ref="tag"/>
                <context sub-pattern="0" where="end" style-ref="tag"/>
                <context ref="generic-tag"/>
                <context id="js-code" extend-parent="false">
                    <start>&gt;</start>
                    <include>
                        <context sub-pattern="0" where="start" style-ref="tag"/>
                        <context ref="js:js"/>
                    </include>
                </context>
            </include>
        </context>
 
        <context id="tag">
            <start>&lt;s*/?s*[a-z0-9_-]+</start>
            <end>/?s*&gt;</end>
            <include>
                <context sub-pattern="0" where="start" style-ref="tag"/>
                <context sub-pattern="0" where="end" style-ref="tag"/>
                <context ref="generic-tag"/>
            </include>
        </context>
 
	<context id="gtag">
		<start>&lt;g:s*/?s*[a-z0-9_-]+</start>
                <end>/?s*&gt;</end>
            	<include>
                	<context sub-pattern="0" where="start" style-ref="tag"/>
                	<context sub-pattern="0" where="end" style-ref="tag"/>
                	<context ref="generic-tag"/>
		</include>
	</context>
 
        <context id="gsp">
            <include>
                <context ref="xml:doctype"/>
                <context ref="xml:entity"/>
                <context ref="xml:character-reference"/>
                <context ref="xml:cdata"/>
                <context ref="comment"/>
                <context ref="dtd"/>
                <context ref="script"/>
                <context ref="tag"/>
                <context ref="gtag"/>
            </include>
        </context>
 
    </definitions>
</language>
 
EOF
 
 
# Copy the mime
sudo cp groovy-gsp-mime.xml /usr/share/mime/packages/groovy.xml
 
# Copy the language spec's
sudo cp groovy.lang gsp.lang /usr/share/gtksourceview-2.0/language-specs/
 
sudo update-mime-database /usr/share/mime
 
# Create an empty groovy file
touch foo.groovy
 
# Check if the mime is properly defined
gnomevfs-info foo.groovy
]]> http://noor.ojuba.org/2008/06/gedit-with-groovy/feed/ 5