teranex weblog - Programmerenhttps://budts.be/2010-12-18T12:31:00+01:00Implicit conversions in C#2009-03-25T18:51:00+01:002010-12-18T12:31:00+01:00Jeroen Budtstag:budts.be,2009-03-25:/weblog/2009/03/implicit-conversions-in-c<p>Yesterday I came across an interesting article: <a href="http://journal.stuffwithstuff.com/2008/04/08/whats-the-opposite-of-nullable/">What's the opposite of Nullable</a>. While the solution for Non-Nullability is interesting, the reason i'm blogging this is because the article also used a C# feature which i didn't know of: implicit conversions.</p>
<p>And guess what? Today I had a situation where I could use these implicit conversions. My app reads data from a CSV-file, so all the input are just strings. Until now that was just fine. However, at one part of my code I had to process one of the fields which has a fixed format. Say a field is a phonenumber and i need the country-prefix. So I created a PhoneNumber-class like this:</p>
<div class="highlight"><pre><span></span><span class="k">public</span> <span class="k">class</span> <span class="nc">PhoneNumber</span>
<span class="p">{</span>
<span class="k">private</span> <span class="k">readonly</span> <span class="kt">string</span> <span class="n">_number</span><span class="p">;</span>
<span class="k">public</span> <span class="nf">PhoneNumber</span><span class="p">(</span><span class="kt">string</span> <span class="n">number</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">if</span> <span class="p">(!</span><span class="k">new</span> <span class="n">Regex</span><span class="p">(</span><span class="n">PHONE_NUMBER_REGEX</span><span class="p">).</span><span class="n">IsMatch</span><span class="p">(</span><span class="n">number</span><span class="p">))</span>
<span class="p">{</span>
<span class="k">throw</span> <span class="k">new</span> <span class="nf">ArgumentException</span><span class="p">(</span><span class="s">"Invalid phone number"</span><span class="p">,</span> <span class="s">"number"</span><span class="p">);</span>
<span class="p">}</span>
<span class="n">_number</span> <span class="p">=</span> <span class="n">number</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">public</span> <span class="kt">string</span> <span class="n">Prefix</span>
<span class="p">{</span>
<span class="k">get</span> <span class="p">{</span> <span class="k">return</span> <span class="n">GetPrefixFromNumber</span><span class="p">(...);</span> <span class="p">}</span>
<span class="p">}</span>
<span class="p">}</span>
</pre></div>
<p>Now it is possible to create a (helper-)method in another class to get the prefix like this (this is just a simple example):</p>
<div class="highlight"><pre><span></span><span class="k">public …</span></pre></div><p>Yesterday I came across an interesting article: <a href="http://journal.stuffwithstuff.com/2008/04/08/whats-the-opposite-of-nullable/">What's the opposite of Nullable</a>. While the solution for Non-Nullability is interesting, the reason i'm blogging this is because the article also used a C# feature which i didn't know of: implicit conversions.</p>
<p>And guess what? Today I had a situation where I could use these implicit conversions. My app reads data from a CSV-file, so all the input are just strings. Until now that was just fine. However, at one part of my code I had to process one of the fields which has a fixed format. Say a field is a phonenumber and i need the country-prefix. So I created a PhoneNumber-class like this:</p>
<div class="highlight"><pre><span></span><span class="k">public</span> <span class="k">class</span> <span class="nc">PhoneNumber</span>
<span class="p">{</span>
<span class="k">private</span> <span class="k">readonly</span> <span class="kt">string</span> <span class="n">_number</span><span class="p">;</span>
<span class="k">public</span> <span class="nf">PhoneNumber</span><span class="p">(</span><span class="kt">string</span> <span class="n">number</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">if</span> <span class="p">(!</span><span class="k">new</span> <span class="n">Regex</span><span class="p">(</span><span class="n">PHONE_NUMBER_REGEX</span><span class="p">).</span><span class="n">IsMatch</span><span class="p">(</span><span class="n">number</span><span class="p">))</span>
<span class="p">{</span>
<span class="k">throw</span> <span class="k">new</span> <span class="nf">ArgumentException</span><span class="p">(</span><span class="s">"Invalid phone number"</span><span class="p">,</span> <span class="s">"number"</span><span class="p">);</span>
<span class="p">}</span>
<span class="n">_number</span> <span class="p">=</span> <span class="n">number</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">public</span> <span class="kt">string</span> <span class="n">Prefix</span>
<span class="p">{</span>
<span class="k">get</span> <span class="p">{</span> <span class="k">return</span> <span class="n">GetPrefixFromNumber</span><span class="p">(...);</span> <span class="p">}</span>
<span class="p">}</span>
<span class="p">}</span>
</pre></div>
<p>Now it is possible to create a (helper-)method in another class to get the prefix like this (this is just a simple example):</p>
<div class="highlight"><pre><span></span><span class="k">public</span> <span class="kt">string</span> <span class="nf">GetPrefix</span><span class="p">(</span><span class="n">PhoneNumber</span> <span class="n">phoneNumber</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">return</span> <span class="n">phoneNumber</span><span class="p">.</span><span class="n">Prefix</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
<p>But when you only have the phonenumber as a string, you'll still have to create an instance of PhoneNumber to be able to call the GetPrefix method:</p>
<div class="highlight"><pre><span></span><span class="kt">var</span> <span class="n">prefix</span> <span class="p">=</span> <span class="n">GetPrefix</span><span class="p">(</span><span class="k">new</span> <span class="n">PhoneNumber</span><span class="p">(</span><span class="s">"+32485123456"</span><span class="p">));</span>
</pre></div>
<p>That is, until we add a method for implicit conversion to the PhoneNumber-class:</p>
<div class="highlight"><pre><span></span><span class="k">public</span> <span class="k">class</span> <span class="nc">PhoneNumber</span>
<span class="p">{</span>
<span class="k">private</span> <span class="kt">string</span> <span class="n">_number</span><span class="p">;</span>
<span class="k">public</span> <span class="nf">PhoneNumber</span><span class="p">(</span><span class="kt">string</span> <span class="n">number</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">if</span> <span class="p">(!</span><span class="k">new</span> <span class="n">Regex</span><span class="p">(</span><span class="n">PHONE_NUMBER_REGEX</span><span class="p">).</span><span class="n">IsMatch</span><span class="p">(</span><span class="n">number</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">throw</span> <span class="k">new</span> <span class="nf">ArgumentException</span><span class="p">(</span><span class="s">"Invalid phone number"</span><span class="p">,</span> <span class="s">"number"</span><span class="p">);</span>
<span class="p">}</span>
<span class="n">_number</span> <span class="p">=</span> <span class="n">number</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">public</span> <span class="kt">string</span> <span class="n">Prefix</span>
<span class="p">{</span>
<span class="k">get</span> <span class="p">{</span> <span class="k">return</span> <span class="n">GetPrefixFromNumber</span><span class="p">(...);</span> <span class="p">}</span>
<span class="p">}</span>
<span class="k">public</span> <span class="k">static</span> <span class="k">implicit</span> <span class="k">operator</span> <span class="nf">PhoneNumber</span><span class="p">(</span><span class="kt">string</span> <span class="n">number</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">return</span> <span class="k">new</span> <span class="nf">PhoneNumber</span><span class="p">(</span><span class="n">number</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">}</span>
</pre></div>
<p>Now it is possible to call the GetPrefix method with just a string. The string will be automagically converted to a PhoneNumber, unless it is invalid, in which case the ArgumentException will be thrown:</p>
<div class="highlight"><pre><span></span><span class="kt">var</span> <span class="n">prefix</span> <span class="p">=</span> <span class="n">GetPrefix</span><span class="p">(</span><span class="s">"+32485123456"</span><span class="p">);</span>
</pre></div>Techdays2009-03-12T23:30:00+01:002010-12-18T12:31:00+01:00Jeroen Budtstag:budts.be,2009-03-12:/weblog/2009/03/techdays<p>Gisteren mocht ik voor het werk een dagje van de <a href="http://www.microsoft.com/belux/techdays/">Microsoft Techdays</a> bijwonen. Het was de eerste keer dat ik naar een Microsoft-event ging en had me eerlijk gezegd aan veel show en weinig inhoud verwacht. In sterk contrast tot <del>JavaPolis</del> <a href="http://www.javoxx.com/">Devoxx</a>, waar er veel inhoud en weinig show is. Achteraf bekeken viel dit eigenlijk enorm goed mee. Enkel de keynote ging er wat over. Een Developer Evangelist of Regional Director moet echt niet als één of andere superster worden aangekondigd met loeiharde muziek en lichtshow, maar dat is mijn mening natuurlijk.</p>
<p>Na de keynote heb ik de sessie over C# 4.0 gevolgd en dat was erg interessant. C# 4.0 belooft weer een versie te worden om naar uit te kijken. Eén van de nieuwe features is het <code>dynamic</code> keyword. Dit zorgt ervoor dat je methodes op het object kan oproepen waarbij de compiler niet checked of deze effectief bestaan. De check wordt pas 'at runtime' gedaan. Dit is erg handig om te integreren met andere talen zoals …</p><p>Gisteren mocht ik voor het werk een dagje van de <a href="http://www.microsoft.com/belux/techdays/">Microsoft Techdays</a> bijwonen. Het was de eerste keer dat ik naar een Microsoft-event ging en had me eerlijk gezegd aan veel show en weinig inhoud verwacht. In sterk contrast tot <del>JavaPolis</del> <a href="http://www.javoxx.com/">Devoxx</a>, waar er veel inhoud en weinig show is. Achteraf bekeken viel dit eigenlijk enorm goed mee. Enkel de keynote ging er wat over. Een Developer Evangelist of Regional Director moet echt niet als één of andere superster worden aangekondigd met loeiharde muziek en lichtshow, maar dat is mijn mening natuurlijk.</p>
<p>Na de keynote heb ik de sessie over C# 4.0 gevolgd en dat was erg interessant. C# 4.0 belooft weer een versie te worden om naar uit te kijken. Eén van de nieuwe features is het <code>dynamic</code> keyword. Dit zorgt ervoor dat je methodes op het object kan oproepen waarbij de compiler niet checked of deze effectief bestaan. De check wordt pas 'at runtime' gedaan. Dit is erg handig om te integreren met andere talen zoals Javascript en Ruby.</p>
<p>Een andere interessante feature is 'Generic co- and contra- variance'. Hiermee kan je in speciale gevallen casts uitvoeren zoals:</p>
<div class="highlight"><pre><span></span><span class="kt">var</span> <span class="n">list</span> <span class="p">=</span> <span class="k">new</span> <span class="n">List</span><span class="p"><</span><span class="kt">string</span><span class="p">>();</span>
<span class="p">(</span><span class="n">List</span><span class="p"><</span><span class="kt">object</span><span class="p">>)</span><span class="n">list</span><span class="p">;</span>
</pre></div>
<p>Ook optional en named parameters behoren tot de nieuwe features. Dit is ook erg interessant. Bekijk dit voorbeeldje:</p>
<div class="highlight"><pre><span></span><span class="k">public</span> <span class="k">void</span> <span class="nf">Order</span><span class="p">(</span><span class="kt">string</span> <span class="n">name</span><span class="p">,</span> <span class="kt">int</span> <span class="n">amount</span> <span class="p">=</span> <span class="m">2</span><span class="p">,</span> <span class="kt">int</span> <span class="n">discount</span> <span class="p">=</span> <span class="m">0</span><span class="p">)</span>
<span class="p">{</span> <span class="p">...</span> <span class="p">}</span>
<span class="n">Order</span><span class="p">(</span><span class="s">"jeroen"</span><span class="p">,</span> <span class="n">dicount</span><span class="p">:</span> <span class="m">5</span><span class="p">);</span>
<span class="c1">// the first param - name - is not optional so a value must be supplied.</span>
<span class="c1">// the second param - amount - has default value of 2 which we want to use</span>
<span class="c1">// the third param - discount - has a default value of 0 but we supply 5</span>
</pre></div>
<p>Enkele belangrijke punten bij het gebruikt van deze feature zijn wel dat je parameters absoluut als constante moet beschouwen. Je kan na verloop van tijd in veel gevallen immers niet zomaar de standaard waarde van een parameter aanpassen. Als je in voorgaand voorbeeld de default value van amount zou wijzigen in 3 zouden er plots veel klanten 3 items bestellen in plaats van 2. Ook is het wijzigen van de naam van een parameter niet meer zo vanzelfsprekend omdat deze naam nu ook buiten de methode wordt gebruikt.</p>
<p>De volgende sessie die ik heb bijgewoond ging over WCF. Hoewel de inhoud nogal vrij droog was, was ook dit wel interessant. Vooral de spreker was nogal een grapjas.</p>
<p>De daaropvolgende presentatie ging over WPF en meer specifiek over performantie. Aan de hand van een demo-applicatie waarin een reeks foto's werden ingeladen werden er enkele gangbare performantie problemen getoond en hoe veel van deze problemen vaak eenvoudig opgelost kunnen worden. Bij het laden van 50 foto's gebruikte de applicatie in het begin 1.3 GB geheugen. Na enkele eenvoudige aanpassingen nog slechts 220 MB. Het belangrijkste deel van de oplossing was om ervoor te zorgen dat het aantal elementen in de WPF-tree zo laag mogelijk werd gehouden. Dit werd onder andere bereikt door een VirtualStackPanel te gebruiken ipv een gewone StackPanel, zodat enkel elementen die effectief op het scherm getoond worden ook berekend worden. Een interessante tool die je hierbij kan helpen is <a href="http://blois.us/Snoop/">Snoop</a>. Dit is een open source programma dat ongeveer hetzelfde werkt als de DOM-explorer in Firefox.</p>
<p>Nog een andere sessie die ik heb gevolgd ging over Lean Principles, Agile Techniques, and Team System. Hierbij weerlegde de presentator 7 gangbare foute veronderstellingen ivm software ontwikkeling. Ook liet hij zien hoe je dit kan toepassen mbhv TFS. Gelukkig ging het niet al teveel over TFS en meer over de algemene theorie waardoor ook deze sessie erg leerrijk was.</p>
<p>De laatste sessie ging over Windows 7 for developers. Tijdens de keynote was Windows 7 al even gedemonstreerd, met nadruk op de (multi-)touch features. Tijdens deze presentatie lag de nadruk echter op de gevolgen en impact van Windows 7 voor developers. Natuurlijk werd er wel eerst een globaal overzicht getoond van de nieuwe taskbar en desktop. Die nieuwe taskbar gaat voor vele mensen even wennen zijn, maar ik denk wel dat het potentieel heeft. Een van de andere nieuwe features die me zo nog te binnen schieten die wel interessant zijn, is het beheer van services. In windows 7 is het namelijk mogelijk om te specifiëren wanneer een bepaalde service moet draaien. Een service die een netwerk verbinding nodig heeft verbruikt bijvoorbeeld enkel maar resources als er geen netwerkverbinding is. In Windows 7 kan die service adhv service triggers op de gepaste momenten in en uitgeschakeld worden.</p>
<p>Ook knap was de problem solver. In Windows XP zat er al een soort van problem solver ingebouwd, maar dit was niet erg interessant. Het stelde oplossingen voor die de gebruiker manueel kon proberen en vroeg telkens of het probleem was opgelost om dan een andere oplossing voor te stellen indien het probleem nog steeds aanwezig was. In Windows 7 gebeurt dit geheel automatisch aan de hand van PowerShell-scripts (als ik het correct begrepen heb). Programma's kunnen ook hun eigen problem solver scripts installeren, zodat dit systeem volledig uitbreidbaar is. Voor veel voorkomende problemen lijkt me dit echt wel een interessante en gebruiksvriendelijk feature. Of deze feature echt zal werken hangt natuurlijk af van de hoeveelheid problemen die de problem solver effectief kan oplossen. De demo was knap, maar het was natuurlijk nog altijd een voorbereid 'probleem' (de audio service werd gestopt en de problem solver wist deze correct terug te starten).</p>
<p>Ik heb echter nog wel een bedenking die ik me achteraf nog heb gemaakt na het bekijken van de presentatie over Windows 7. Windows 7 bevat standaard functionaliteit om je eigen applicatie van een ribbon te voorzien (een soort van knoppenbalk zoals in Office 2007), en er werd sterk benadrukt naar developers toe om dit ook te gebruiken. Tijdens andere presentaties kon je al een preview zien van Visual Studio 2010. Het vlaggenschip voor development van Microsoft. En wat valt mij daarbij op? Microsoft maakt hier zelf geen gebruik van de ribbon. Mij lijkt dit toch weer een inconsistentie in de Windows-omgeving. Of zou Microsoft dan toch niet zoveel vertrouwen hebben in de ribbon?</p>Boekenfestijn2005-05-26T17:48:00+02:002010-12-18T12:31:00+01:00Jeroen Budtstag:budts.be,2005-05-26:/weblog/2005/05/boekenfestijn<p><img src="/weblog/media/programming/20050526-boekenfestijn.png" alt="Boeken" class="alignLeft" />
<p><a href="http://budts.be/weblog/item/322">Net zoals vorig jaar</a> is het weer <a href="http://www.boekenfestijn.com">boekenfestijn</a> in het bouwcentrum in Antwerpen. Ook dit jaar waren er weer ?norm veel interessante boeken. Je zou er echt gemakkelijk een grote winkelkar volkrijgen met stuk voor stuk interessante boeken. (sommige mensen doen dat dan ook :D). Zelf heb ik het bij 3 boeken gehouden: <a href="http://manning.com/massol">JUnit</a>, <a href="http://manning.com/lewisship">Tapestry</a> en <a href="http://manning.com/walls">XDoclet</a>, allemaal van Manning.</p></p><p><img src="/weblog/media/programming/20050526-boekenfestijn.png" alt="Boeken" class="alignLeft" />
<p><a href="http://budts.be/weblog/item/322">Net zoals vorig jaar</a> is het weer <a href="http://www.boekenfestijn.com">boekenfestijn</a> in het bouwcentrum in Antwerpen. Ook dit jaar waren er weer ?norm veel interessante boeken. Je zou er echt gemakkelijk een grote winkelkar volkrijgen met stuk voor stuk interessante boeken. (sommige mensen doen dat dan ook :D). Zelf heb ik het bij 3 boeken gehouden: <a href="http://manning.com/massol">JUnit</a>, <a href="http://manning.com/lewisship">Tapestry</a> en <a href="http://manning.com/walls">XDoclet</a>, allemaal van Manning.</p></p>Standardizing BeanShell2005-05-26T01:17:00+02:002010-12-18T12:31:00+01:00Jeroen Budtstag:budts.be,2005-05-26:/weblog/2005/05/standardizing-beanshell<p>A while ago, when <a href="http://budts.be/weblog/item/467">I first wrote about Groovy</a>, I started wondering why there wasn't a JSR for Beanshell. As you might know, Beanshell is, just like Groovy, a scripting language for Java. Today Pat, the main Beanshell developer, <a href="http://permalink.gmane.org/gmane.comp.java.beanshell.user/1235">announced</a> that Beanshell will be standardized in <a href="http://jcp.org/en/jsr/detail?id=274">JSR 274</a>. You can <a href="http://weblogs.java.net/blog/pat/archive/2005/05/jsr274_standard_1.html">read more about this on his blog</a>.</p><p>A while ago, when <a href="http://budts.be/weblog/item/467">I first wrote about Groovy</a>, I started wondering why there wasn't a JSR for Beanshell. As you might know, Beanshell is, just like Groovy, a scripting language for Java. Today Pat, the main Beanshell developer, <a href="http://permalink.gmane.org/gmane.comp.java.beanshell.user/1235">announced</a> that Beanshell will be standardized in <a href="http://jcp.org/en/jsr/detail?id=274">JSR 274</a>. You can <a href="http://weblogs.java.net/blog/pat/archive/2005/05/jsr274_standard_1.html">read more about this on his blog</a>.</p>Debugging with Eclipse2005-05-22T21:13:00+02:002010-12-18T12:31:00+01:00Jeroen Budtstag:budts.be,2005-05-22:/weblog/2005/05/debugging-with-eclipse<p>Ofcourse Eclipse has a debugger which you can use to debug your Java applications. Like most other debuggers you can set breakpoints, view variables, use watch expressions, inspect objects and use actions like 'step into', 'step over' and so on.</p>
<p>But Friday I discovered another nice feature while debugging: When you change some of your code while debugging you don't need to restart your application. Eclipse simply uses your new code. Something similar is possible with the debugger of Visual Studio 6 and will be possible again in Visual Studio 2005.</p>
<p>Here is a, rather stupid, example to illustrate it:</p>
<p>I created a method 'getList()' in the class 'Foobar' which should return a List with two elements. Ofcourse i create a UnitTest for it:</p>
<p><img alt="Debugging with Eclipse: an Example" src="/weblog/media/eclipse/20050522-eclipse-debugging02.png" />
<!--break-->
<p>Now suppose i just returned a new arraylist in getList() instead of the one i created in that function. Ofcourse the test will fail:</p>
<img alt="Debugging with Eclipse: an Example" src="/weblog/media/eclipse/20050522-eclipse-debugging01.png" />
<p>So i set a breakpoint somewhere in the method 'getList()' (ofcourse i would have discovered the reason for the bug by now …</p></p><p>Ofcourse Eclipse has a debugger which you can use to debug your Java applications. Like most other debuggers you can set breakpoints, view variables, use watch expressions, inspect objects and use actions like 'step into', 'step over' and so on.</p>
<p>But Friday I discovered another nice feature while debugging: When you change some of your code while debugging you don't need to restart your application. Eclipse simply uses your new code. Something similar is possible with the debugger of Visual Studio 6 and will be possible again in Visual Studio 2005.</p>
<p>Here is a, rather stupid, example to illustrate it:</p>
<p>I created a method 'getList()' in the class 'Foobar' which should return a List with two elements. Ofcourse i create a UnitTest for it:</p>
<p><img alt="Debugging with Eclipse: an Example" src="/weblog/media/eclipse/20050522-eclipse-debugging02.png" />
<!--break-->
<p>Now suppose i just returned a new arraylist in getList() instead of the one i created in that function. Ofcourse the test will fail:</p>
<img alt="Debugging with Eclipse: an Example" src="/weblog/media/eclipse/20050522-eclipse-debugging01.png" />
<p>So i set a breakpoint somewhere in the method 'getList()' (ofcourse i would have discovered the reason for the bug by now, but i told you it was a stupid example ;)). And i start debugging. When the debugger reaches my breakpoint I discover my mistake:</p>
<img alt="Debugging with Eclipse: an Example" src="/weblog/media/eclipse/20050522-eclipse-debugging03.png" />
<p>ofcourse 'return new ArrayList<Integer>();' should be 'return l;', so I change it. Then I hit Ctrl+S to save the changes and (now comes the magic) Eclipse immediately notices the changes and sets the programcounter back to the beginning of the method:</p>
<img alt="Debugging with Eclipse: an Example" src="/weblog/media/eclipse/20050522-eclipse-debugging04.png" />
<p>When i now continue, my UnitTest succeeds :):</p>
<img alt="Debugging with Eclipse: an Example" src="/weblog/media/eclipse/20050522-eclipse-debugging05.png" />
<p>Another cool tool that can be useful while debugging is the <a href="http://www.csg.is.titech.ac.jp/~usui/bugdel/index-e.shtml">BugDel Plugin</a>. With this plugin it is very easy to use AOP [<a href="http://en.wikipedia.org/wiki/Aspect-oriented_programming">Aspect Oriented Programming</a>] during debugging. With BugDel it is very easy to add aspects to specific lines or, by example, to all your getters and setters. See the website for some <a href="http://www.csg.is.titech.ac.jp/~usui/bugdel/demo/index.html">cool Flash-demos</a>.</p></p>Eclipse, not just an IDE2005-05-19T01:47:00+02:002010-12-18T12:31:00+01:00Jeroen Budtstag:budts.be,2005-05-19:/weblog/2005/05/eclipse-not-just-an-ide<p><img alt="Eclipse Logo" src="/weblog/media/logos/eclipse.jpg" class="alignLeft" />
<p>In the past half year i have been doing two projects, of which one in <a href="http://www.microsoft.com/net/">.NET</a> (C#) and one in <a href="http://java.sun.com/">Java</a>. As far as i can tell now I certainly prefer Java over .NET. Although with "out-of-the-box"-programming in .NET (with "out-of-the-box" i mean simply installing Visual Studio) you will get a result in less time, .NET misses the big (<a href="http://opensource.org/">Open Source</a>) community that Java has. While there are expensive <a href="http://en.wikipedia.org/wiki/Integrated_Development_Environment">IDE</a>'s for Java, like <a href="http://www.jetbrains.com/idea/">IntelliJ</a>, there are also various Open Source alternatives, of which <a href="http://www.netbeans.org/">NetBeans</a> and <a href="http://eclipse.org">Eclipse</a> are the two most well known.</p>
<p>Especially Eclipse is an extremely beautiful IDE, if not the best IDE ever created. But Eclipse is more then just an IDE. In fact it is a platform to create IDE's. And by default, when you download the official Eclipse release, it comes with <a href="http://eclipse.org/jdt/">JDT</a>, the Java Development Tools. The architecture of Eclipse is completely build on the idea of plugins. Almost every part of Eclipse is a plugin, including the Eclipse core. This is one …</p></p><p><img alt="Eclipse Logo" src="/weblog/media/logos/eclipse.jpg" class="alignLeft" />
<p>In the past half year i have been doing two projects, of which one in <a href="http://www.microsoft.com/net/">.NET</a> (C#) and one in <a href="http://java.sun.com/">Java</a>. As far as i can tell now I certainly prefer Java over .NET. Although with "out-of-the-box"-programming in .NET (with "out-of-the-box" i mean simply installing Visual Studio) you will get a result in less time, .NET misses the big (<a href="http://opensource.org/">Open Source</a>) community that Java has. While there are expensive <a href="http://en.wikipedia.org/wiki/Integrated_Development_Environment">IDE</a>'s for Java, like <a href="http://www.jetbrains.com/idea/">IntelliJ</a>, there are also various Open Source alternatives, of which <a href="http://www.netbeans.org/">NetBeans</a> and <a href="http://eclipse.org">Eclipse</a> are the two most well known.</p>
<p>Especially Eclipse is an extremely beautiful IDE, if not the best IDE ever created. But Eclipse is more then just an IDE. In fact it is a platform to create IDE's. And by default, when you download the official Eclipse release, it comes with <a href="http://eclipse.org/jdt/">JDT</a>, the Java Development Tools. The architecture of Eclipse is completely build on the idea of plugins. Almost every part of Eclipse is a plugin, including the Eclipse core. This is one of the reasons why Eclipse is so nice. It is very easy to add new functionality to the IDE, or even to completely create a new IDE build on top of the platform. Because of the license of the Eclipse platform, both Open Source and commercial plugins are allowed. And as you can see on sites like <a href="http://eclipse-plugins.info/eclipse/index.jsp">eclipse-plugins.info</a> there are <em>a lot</em> of plugins available, of which a vast amount is developped as Open Source.</p>
<p>Although a lot of people use Eclipse to develop Java you can use it for a lot more because of the plugins. Examples include: <a href="http://www.eclipse.org/cdt/">C++</a>, <a href="http://www.eclipse.org/cobol/">COBOL</a>, <a href="http://www.xored.com/trustudio">PHP & Python</a>, <a href="http://eclipsefp.sourceforge.net/">Haskell</a>, <a href="http://eclipsensis.sourceforge.net/">NSIS</a> or even <a href="http://www.visual-paradigm.com/product/sde/ec/">UML</a> and more...</p></p>
<!--break-->
<p>Ofcourse the Java Development Tools itself are also very well designed and provide a very comfortable environment to the Java-programmer. It has basic features like syntax highlighting, Code Assist, syntax checking etc, but also more advanced features like <a href="http://www.refactoring.com/">refactoring</a>. An example of a simple refactoring is renaming a file (more complex refactorings are also available): You simply select "Refactor > Rename...", enter a new name, and Eclipse updates all the references that should be updated, so that your code compiles without any further changes (also works for methods and properties). Compare this to Visual Studio where you simply rename the file, compile and check the compiler errors for all the places where you need to update your code... (Visual Studio 2005 (whidbey) will have such refactorings also).</p>
<p>I still have a lot to tell about Eclipse and all the plugins I already tested and plan to test, so I will try to write an article from time to time introducing nice plugins for Eclipse and/or other nice features in Eclipse.</p>
<p>In case you are interested, a list of plugins i use, have tested and plan to test can be found at my <a href="http://wiki.budts.be/prefs:eclipse">wiki</a>.</p>Groovy: Java Scripting (NL)2005-05-17T10:46:00+02:002010-12-18T12:31:00+01:00Jeroen Budtstag:budts.be,2005-05-17:/weblog/2005/05/groovy-java-scripting-nl<p><small style="color: gray;">Dit is de Nederlandse vertaling van een <a href="http://budts.be/weblog/item/467">artikel</a> dat ik een tijdje terug in het engels schreef. Bedankt <a href="http://lightyearin.skynetblogs.be/">Vicky</a> voor de vertaling!</small></p>
<p>Een paar dagen geleden struikelde ik over <a href="http://www.onjava.com/pub/a/onjava/2004/09/29/groovy.html">een artikel</a> dat bij <a href="http://www.onjava.com/">onjava.com</a> <a href="http://groovy.codehaus.org/">Groovy</a> introduceert. Groovy is een scripting taal voor <a href="http://java.sun.com/">Java</a>, dit betekent dat de groovy-scripts kunnen worden uitgevoerd zonder dat ze eerst moeten worden gecompileerd. Dit maakt het zeer gemakkelijk om kleine scriptjes te schrijven die vanaf de commandoregel of van binnenin een Java-applicatie kunnen worden uitgevoerd.</p>
<!--break-->
<p>Groovy is niet de enige scripting taal voor Java. Andere zijn onder andere <a href="http://beanshell.org/">Beanshell</a>, <a href="http://www.jython.org/">Jython</a>, <a href="http://jruby.sourceforge.net/">JRuby</a> en etc. Een aardig overzicht kan <a href="http://www.javaworld.com/javaworld/jw-03-2005/jw-0314-scripting_p.html">hier</a> worden gevonden. De mensen die <a href="http://jedit.org/">jEdit</a> gebruiken zullen zeker al van Beanshell gehoord hebben aangezien het de taal is die door jEdit wordt gebruikt Macro's te schrijven.</p>
<p>Zowel Groovy als Beanshell gebruiken een syntaxis die op Java wordt gebaseerd, maar hun doelstellingen zijn een beetje verschillend. Beanshell probeert normale Java documenten te vertalen en lijkt dit zeer goed te doen. Door Beanshell te gebruiken zou het …</p><p><small style="color: gray;">Dit is de Nederlandse vertaling van een <a href="http://budts.be/weblog/item/467">artikel</a> dat ik een tijdje terug in het engels schreef. Bedankt <a href="http://lightyearin.skynetblogs.be/">Vicky</a> voor de vertaling!</small></p>
<p>Een paar dagen geleden struikelde ik over <a href="http://www.onjava.com/pub/a/onjava/2004/09/29/groovy.html">een artikel</a> dat bij <a href="http://www.onjava.com/">onjava.com</a> <a href="http://groovy.codehaus.org/">Groovy</a> introduceert. Groovy is een scripting taal voor <a href="http://java.sun.com/">Java</a>, dit betekent dat de groovy-scripts kunnen worden uitgevoerd zonder dat ze eerst moeten worden gecompileerd. Dit maakt het zeer gemakkelijk om kleine scriptjes te schrijven die vanaf de commandoregel of van binnenin een Java-applicatie kunnen worden uitgevoerd.</p>
<!--break-->
<p>Groovy is niet de enige scripting taal voor Java. Andere zijn onder andere <a href="http://beanshell.org/">Beanshell</a>, <a href="http://www.jython.org/">Jython</a>, <a href="http://jruby.sourceforge.net/">JRuby</a> en etc. Een aardig overzicht kan <a href="http://www.javaworld.com/javaworld/jw-03-2005/jw-0314-scripting_p.html">hier</a> worden gevonden. De mensen die <a href="http://jedit.org/">jEdit</a> gebruiken zullen zeker al van Beanshell gehoord hebben aangezien het de taal is die door jEdit wordt gebruikt Macro's te schrijven.</p>
<p>Zowel Groovy als Beanshell gebruiken een syntaxis die op Java wordt gebaseerd, maar hun doelstellingen zijn een beetje verschillend. Beanshell probeert normale Java documenten te vertalen en lijkt dit zeer goed te doen. Door Beanshell te gebruiken zou het in principe mogelijk moeten zijn om een echte Java-applicatie uit te voeren door de broncode door Beanshell te duwen, in plaats van hen te compileren naar .class-bestanden. Het doel van Groovy is een makkelijk te gebruiken scripting taal te zijn, door wat "suikercode" toe te voegen, om het gemakkelijker te maken om mee te ontwikkelen.</p>
<p>Een voorbeeld:<code>
System.out.println("this is a foobar!");<br />
println "this is another foobar!"</code>
Beide lijnen zijn geldige groovy-Syntaxis en doen precies hetzelfde: een lijn op het scherm afdrukken. Nochtans is de tweede lijn, in "groovy-Stijl" veel gemakkelijker dan de eerste lijn, die de normale syntaxis van Java gebruikt.</p>
<p>Een ander voorbeeld van suikercode is een ander soort 'foreach' die gebruikmaak van 'closures':<code>
l = [1,2,"foo"];<br />
<br />
l.each {<br />
println "item ${it}";<br />
};</code>
Wat in deze code gebeurt is het volgende: eerst wordt een lijst ' l ' gecre?erd met elementen 1, 2 en een string "foo". Voor ieder element van de lijst wordt er een regel naar het scherm afgedrukt, wat resulteert in:<code>
item 1<br />
item 2<br />
item foo</code>
(en het illustreert ook autoboxing).</p>
<p>Twee andere aardige dingen over Groovy zijn dat
Het is mogelijk om Groovy-scripts in naar standaard Java-code te compileren (.class-files). Dit geeft klassen die in om het even welke Java-applicatie kunnen worden gebruikt.</p>
<p>Het is zeer gemakkelijk om Groovy-scripten vanop de commandoregel te gebruiken.
Eenvoudig typen <code>$ groovy myscript.groovy</code> lanceert het script. Wanneer u een *nix omgeving gebruikt (cygwin onder andere) is het nog gemakkelijker: begin de scriptfile met <code>#!/usr/bin/env groovy</code> en je kan het script starten met <code>$ ./myscript.groovy</code></p>
<p>Iets anders dat speciaal aan Groovy is, is dat het als <a href="http://www.jcp.org/en/jsr/detail?id=241">JSR</a> wordt goedgekeurd. Het verwonderd me waarom Beanshell geen JSR heeft, aangezien het veel dichter bij Java lijkt te staan dan Groovy.</p>
<p>De reden waarom het artikel bij onjava.com mijn aandacht trok was dat ik een paar maanden geleden al over Groovy had gelezen. Nochtans was dat in een volledige andere context: <a href="http://beust.com/weblog/archives/000235.html">een open brief van Cedric Beust</a> (die een interessant <a href="http://beust.com/weblog/">blog</a> heeft btw ) aan de belangrijkste ontwikkelaar van Groovy. In de brief zegt Cedric dat de ontwikkelaar er een knoeiboel van aan het maken was, door geen roadmap te gebruiken en altijd nieuwe eigenschappen toe te voegen in plaats van eerst een versie 1.0 af te werken. Dit gaf me een eerder negatief gevoel over Groovy en gaf me het gevoel dat Beanshell een betere keuze was dan Groovy. Maar nu ik een beetje met Groovy heb gespeeld, hou ik er ook van en denk ik dat het gewoon 'anders' is dan Beanshell.</p>
<p>Als eindgebruiker ben ik zeer gelukkig met wat ik van Groovy tot nu toe heb gezien. Maar natuurlijk maakt deze negatieve kritiek me een beetje ongerust. Ik investeer liever geen tijd in het leren van een taal die in toekomst dood zal zijn. Tot nu toe denk ik dat ik beide talen zal leren, Beanshell om macro's te schrijven in jEdit (hoewel dat ook mogelijk is met Groovy) en Groovy om scripts te schrijven voor de commandoregel (en dit is ook mogelijk met Beanshell)</p>uit de oude doos: MasterMind 20012005-05-11T00:17:00+02:002010-12-18T12:31:00+01:00Jeroen Budtstag:budts.be,2005-05-11:/weblog/2005/05/uit-de-oude-doos-mastermind-2001<p><img alt="Mastermind screenshot" src="/weblog/media/programming/20050511-mastermind.png" class="alignLeft" />
<p>Zonet was ik wat opkuis aan het houden in ??n van de vele mappen op m'n harde schijf. Toevallig kwam ik wat oude spulletjes tegen die ik vroeger eens had geschreven. E?ntje daarvan is een eenvoudige MasterMind, geschreven in VB6. En ja hij werkte zelfs :). Omdat hij toch maar op m'n schijf 'stof stond te vangen' heb ik hem online gezet, met de broncodes erbij (GPL-ed).</p>
<p>Ik wil er overigens wel bijzeggen dat deze code van 2001 dateert en het design van het programmaatje op zo goed als niets trekt. Vandaag de dag programmeer ik wel net iets properder ;) En ook: als het ding uw computer laat crashen, ontploffen of begint op te eten, ik ben NIET verantwoordelijk ;)</p>
<p>Dat gezegd zijnde: <br/>
<a href="http://dev.budts.be/releases/old/">http://dev.budts.be/releases/old/</a><br/>
De zip downloaden, uitpakken en MasterMind.exe starten en je bent vertrokken :)
</p></p><p><img alt="Mastermind screenshot" src="/weblog/media/programming/20050511-mastermind.png" class="alignLeft" />
<p>Zonet was ik wat opkuis aan het houden in ??n van de vele mappen op m'n harde schijf. Toevallig kwam ik wat oude spulletjes tegen die ik vroeger eens had geschreven. E?ntje daarvan is een eenvoudige MasterMind, geschreven in VB6. En ja hij werkte zelfs :). Omdat hij toch maar op m'n schijf 'stof stond te vangen' heb ik hem online gezet, met de broncodes erbij (GPL-ed).</p>
<p>Ik wil er overigens wel bijzeggen dat deze code van 2001 dateert en het design van het programmaatje op zo goed als niets trekt. Vandaag de dag programmeer ik wel net iets properder ;) En ook: als het ding uw computer laat crashen, ontploffen of begint op te eten, ik ben NIET verantwoordelijk ;)</p>
<p>Dat gezegd zijnde: <br/>
<a href="http://dev.budts.be/releases/old/">http://dev.budts.be/releases/old/</a><br/>
De zip downloaden, uitpakken en MasterMind.exe starten en je bent vertrokken :)
</p></p>Groovy: Java Scripting2005-05-03T22:22:00+02:002010-12-18T12:31:00+01:00Jeroen Budtstag:budts.be,2005-05-03:/weblog/2005/05/groovy-java-scripting<p style="size: smaller; color: gray;">See <a href="#why-is-this-written-in-english">below</a> for an explanation why this is written in English</p>
<p><img src="/weblog/media/logos/groovy.png" alt="Groovy logo" class="alignLeft" />
<p>A few days ago I stumbled across <a href="http://www.onjava.com/pub/a/onjava/2004/09/29/groovy.html">an article</a> at <a href="http://www.onjava.com/">onjava.com</a> introducing <a href="http://groovy.codehaus.org/">Groovy</a>. Groovy is a scripting language for <a href="http://java.sun.com/">Java</a>, meaning that Groovy-scripts can be executed without the need of first being compiled. This makes it very easy to write little scripts which can be executed from the command-line or from inside a java application.</p>
<p>Groovy is not the only scripting language for Java. Others include <a href="http://beanshell.org/">Beanshell</a>, <a href="http://www.jython.org/">Jython</a>, <a href="http://jruby.sourceforge.net/">JRuby</a> and some more. A nice overview can be found <a href="http://www.javaworld.com/javaworld/jw-03-2005/jw-0314-scripting_p.html">here</a>. People that use <a href="http://jedit.org">jEdit</a> will certainly have heard of Beanshell since it is the language used by jEdit to write Macro's.</p>
<p>Both Groovy and Beanshell use a syntax based on Java, but their goals are a bit different. Beanshell tries to interprete normal java files and seems to do this very well. So by using Beanshell it should be possible to run a real Java application by feeding the source files to Beanshell, instead of compiling them into .class-files …</p></p><p style="size: smaller; color: gray;">See <a href="#why-is-this-written-in-english">below</a> for an explanation why this is written in English</p>
<p><img src="/weblog/media/logos/groovy.png" alt="Groovy logo" class="alignLeft" />
<p>A few days ago I stumbled across <a href="http://www.onjava.com/pub/a/onjava/2004/09/29/groovy.html">an article</a> at <a href="http://www.onjava.com/">onjava.com</a> introducing <a href="http://groovy.codehaus.org/">Groovy</a>. Groovy is a scripting language for <a href="http://java.sun.com/">Java</a>, meaning that Groovy-scripts can be executed without the need of first being compiled. This makes it very easy to write little scripts which can be executed from the command-line or from inside a java application.</p>
<p>Groovy is not the only scripting language for Java. Others include <a href="http://beanshell.org/">Beanshell</a>, <a href="http://www.jython.org/">Jython</a>, <a href="http://jruby.sourceforge.net/">JRuby</a> and some more. A nice overview can be found <a href="http://www.javaworld.com/javaworld/jw-03-2005/jw-0314-scripting_p.html">here</a>. People that use <a href="http://jedit.org">jEdit</a> will certainly have heard of Beanshell since it is the language used by jEdit to write Macro's.</p>
<p>Both Groovy and Beanshell use a syntax based on Java, but their goals are a bit different. Beanshell tries to interprete normal java files and seems to do this very well. So by using Beanshell it should be possible to run a real Java application by feeding the source files to Beanshell, instead of compiling them into .class-files. The goal of Groovy is to provide an easy to use scripting language, by adding some "sugar code", to make it easier to develop with. An example:
<code>
System.out.println("this is a foobar!");<br />
println "this is another foobar!"
</code>
Both lines are valid Groovy-syntax and do exactly the same: print a line to the screen. However the second line, in "Groovy-style" is much easier then the first line, which uses regular Java syntax.</p>
<p>Another example of sugar code is some kind of 'foreach' using 'closures':
<code>
l = [1,2,"foo"];<br />
<br />
l.each {<br />
println "item ${it}";<br />
};
</code>
What happens in this code is the following: first a list 'l' is created with elements 1, 2 and a string "foo". This list is iterated and for every item a string is printed to the screen which results in:
<code>
item 1<br />
item 2<br />
item foo
</code>
(and it also illustrates autoboxing).</p></p>
<p>Two other nice things about Groovy are that</p>
<ul>
<li>It is possible to compile Groovy scripts into regular Java code. This gives you classes that can be used in any regular Java application.</li>
<li>It is very easy to run Groovy scripts from the command-line. Simply typing <code>$ groovy myscript.groovy</code> launches the script. When you're using a *nix environment (includig cygwin) it is even easier: start the script file with <code>#!/usr/bin/env groovy</code> and you can start your script with <code>$ ./myscript.groovy</code></li>
</ul>
<p>Something else that's special about Groovy is that it is accepted as a <a href="http://www.jcp.org/en/jsr/detail?id=241">JSR</a> (Java Specification Request). That makes me wonder why Beanshell doesn't have a JSR, since it is much closer to Java than Groovy.</p>
<p>The reason why the article at onjava.com attracted my attention was that i had already read about Groovy a few months earlier. However that was in a complete different context: <a href="http://beust.com/weblog/archives/000235.html">an open letter from Cedric Beust</a> (who has an interesting <a href="http://beust.com/weblog/">blog</a> btw) to the main developer of Groovy telling him he was making a mess of Groovy by not using a roadmap and always adding new features instead of working towards a 1.0 release. This gave me a rather negative feeling about Groovy and made me think Beanshell was a lot better then Groovy. But now that i have been playing a bit with Groovy i really like that too and think it is just 'different' from Beanshell. As an end user i'm very happy with what i have seen from Groovy until now. But ofcourse this negative criticism worries me a bit. I'd rather not invest my time in learning a language which will be dead in the future... Until now i think i'll just continue learning both the languages, Beanshell to write macro's in jEdit (although that's also possible with Groovy) and Groovy to write scripts for the command-line (and this is also possible with Beanshell)</p>
<p id="why-is-this-written-in-english" style="font: smaller; color: gray;">So why is this item written in english?<br/>
Since a few months now i'm considering to write my tech-related articles in english to make them available to more people. For my 'regular' blog items i think Dutch is just fine and i will keep writing them in Dutch. I think i will just give it a try and see if i (and others) like it. (and you are free to correct my spelling mistakes, it can only have a positive influence :) )</p>
<p>A nice presentation of Groovy can be found <a href="http://viva.sourceforge.net/talk/jug-mar-2004/slides.html">here</a></p>darcs: versiebeheer op een nieuwe manier2005-04-27T00:02:00+02:002010-12-18T12:31:00+01:00Jeroen Budtstag:budts.be,2005-04-27:/weblog/2005/04/darcs-versiebeheer-op-een-nieuwe-manier<p><img src="/weblog/media/logos/darcs.png" alt="darcs logo" class="alignLeft" />
<p>Toen Andreas Gohr enkele maanden geleden opzoek ging naar een geschikte <a href="http://wiki.splitbrain.org/wiki:darcs">source control-tool voor DokuWiki</a> koos hij voor <a href="http://www.darcs.net">darcs</a>. Het was de eerste keer dat ik van darcs hoorde, maar sindsdien ben ik het meer en meer tegengekomen.</p>
<p>In vergelijking met 'klassieke' SCM-tools, zoals <a href="http://cvshome.org">CVS</a>, <a href="http://subversion.tigris.org/">Subversion</a> en <a href="http://msdn.microsoft.com/vstudio/previous/ssafe/">SourceSafe</a>, werkt darcs opmerkelijk anders. Bij deze klassieke systemen heb je meestal enerzijds een centrale server met een 'repository' waar al de code wordt bewaard en anderzijds een sandbox op je lokale computer die alle bestanden bevat waaraan je kan werken. darcs echter is een gedistribueerd systeem. Hierbij is dus iedere 'sandbox' ook meteen een 'repository'. Dat heeft aardig wat voordelen. Zo moet je bijvoorbeeld geen verbinding hebben met een server om bewerkingen op de repository uit te voeren.</p>
<p>In tegenstelling tot CVS werkt darcs niet met versies van bestanden maar met 'patchsets'. Zo'n patchset wordt gemaakt aan de hand van alle wijzigingen die je aanbracht ten opzichte van je lokale repository. Dit is handig want op die manier zitten alle wijzigingen die …</p></p><p><img src="/weblog/media/logos/darcs.png" alt="darcs logo" class="alignLeft" />
<p>Toen Andreas Gohr enkele maanden geleden opzoek ging naar een geschikte <a href="http://wiki.splitbrain.org/wiki:darcs">source control-tool voor DokuWiki</a> koos hij voor <a href="http://www.darcs.net">darcs</a>. Het was de eerste keer dat ik van darcs hoorde, maar sindsdien ben ik het meer en meer tegengekomen.</p>
<p>In vergelijking met 'klassieke' SCM-tools, zoals <a href="http://cvshome.org">CVS</a>, <a href="http://subversion.tigris.org/">Subversion</a> en <a href="http://msdn.microsoft.com/vstudio/previous/ssafe/">SourceSafe</a>, werkt darcs opmerkelijk anders. Bij deze klassieke systemen heb je meestal enerzijds een centrale server met een 'repository' waar al de code wordt bewaard en anderzijds een sandbox op je lokale computer die alle bestanden bevat waaraan je kan werken. darcs echter is een gedistribueerd systeem. Hierbij is dus iedere 'sandbox' ook meteen een 'repository'. Dat heeft aardig wat voordelen. Zo moet je bijvoorbeeld geen verbinding hebben met een server om bewerkingen op de repository uit te voeren.</p>
<p>In tegenstelling tot CVS werkt darcs niet met versies van bestanden maar met 'patchsets'. Zo'n patchset wordt gemaakt aan de hand van alle wijzigingen die je aanbracht ten opzichte van je lokale repository. Dit is handig want op die manier zitten alle wijzigingen die bij elkaar horen in ??n patchset samen. Het delen van je wijzigingen in de vorm van patchsets is dan ook erg makkelijk.</p>
<p>Een ander groot verschil tussen systemen zoals CVS enerzijds en darcs anderzijds is het updaten van de code met de recentste code van andere mensen die mee aan het project werken. Met CVS doe je dit met behulp van het commando <code>cvs update</code> Dit commando haalt de meest recente versies van alle bestanden op vanop de CVS-server. Omdat darcs een gedistribueerd systeem is en dus niet met een centrale server werkt gebeurt het synchroniseren op een aantal andere manieren. Zo zijn er de commando's <code>darcs pull</code> en <code>darcs push</code> Deze commando's brengen wijzigingen uit een andere repository over naar jouw repository ('overtrekken'), respectievelijk voeren de wijzigingen uit jouw repository door op een andere repository (duwen dus). Deze methodes werken natuurlijk enkel als je de nodige lees- ?n schrijfrechten hebt op die andere repository (schrijfrechten zijn enkel nodig voor een push). Een andere manier om te synchroniseren, waarbij je geen toegang moet hebben tot de andere 'repo' is <code>darcs send</code> Dit verstuurt de patch via e-mail naar de eigenaar van de andere repository. Ook <code>darcs send -o patchfile</code> is erg handig. In plaats van de patch te mailen schrijft het alle data weg naar 'patchfile', zodat je het manueel kan mailen of bijvoorbeeld als attachment in je bugtracker kan stoppen. Wanneer je een patch ontvangt kan je die h??l eenvoudig op je repository toepassen: <code>darcs apply patchfile</code></p>
<p>Erg handig aan darcs is dat je een repository online kan plaatsen via een eenvoudige webserver. Nadat je een repository op je webserver hebt gezet, bijvoorbeeld via ftp, kan iedereen een <code>darcs get http://example.org/my/darcs/repo</code> doen met de url. Op die manier heeft iedereen die dat wenst leestoegang tot je repository en kan men lokaal wijzigingen maken. Deze wijzigingen kunnen dan eventueel weer in de vorm van een patchfile naar de eigenaar van de repository gemaild worden. Door een repository op een server beschikbaar te maken maak je het ook makkelijker om te synchroniseren omdat deze repository dan beschouwd kan worden als de 'moederrepository'. Iedereen is echter steeds vrij om z'n lokale repository al dan niet te synchroniseren met deze moederrepository.</p>
<p>Vermits darcs met patches werkt is het ook perfect mogelijk om een eigen aangepaste versie te maken van een applicatie die je toch automatisch kan updaten met offici?le code zonder je eigen wijzigingen te verliezen.</p>
<p>Hoewel ik nog niet zo heel veel heb kunnen experimenteren met darcs vind ik het tot hiertoe een zeer knap systeem. Zeker voor kleinere projecten lijkt het me erg geschikt. Ik plan dan ook om voor m'n eigen kleinere projectjes, zoals <a href="http://nucleuscms.org">Nucleus</a> Plugins, CVS in te ruilen voor darcs. Ik heb alvast een plekje opgezet waar ik al m'n repo's online zal plaatsen: <a href="http://dev.budts.be/darcs/">http://dev.budts.be/darcs/</a>. Momenteel vind je daar al een <a href="http://dev.budts.be/darcs/NP_AttachFile/HEAD/">repo met de meest recente code van AttachFile</a>, een Nucleus plugin waaraan ik momenteel werk.</p>
<p>Wat momenteel nog wel als een nadeel kan overkomen, vooral dan voor (windows)gebruikers die niet gewend zijn aan de commandline, is dat er nog geen enkele grafische interface beschikbaar is voor darcs. Hieraan wordt echter wel gewerkt door afzonderlijke projecten, zoals bijvoorbeeld <a href="http://eclipsedarcs.sourceforge.net/">EclipseDarcs</a>.</p>
<p>Het overzetten van een bestaande repository, bijvoorbeeld je CVS repository, is vrij makkelijk met de verschillende tooltjes die beschikbaar zijn. Het <a href="http://www.darcs.net/DarcsWiki/ConvertingFromCvs">overzetten van mijn CVS</a> repository voor de AttachFile-plugin naar een darcs repository ging bijvoorbeeld vrij gemakkelijk met het <a href="http://ab-initio.mit.edu/cvs2darcs/">cvs2darcs</a> tooltje. Hoewel ik hiervoor wel even heb voor moeten prutsen met <a href="http://cygwin.com">Cygwin</a> en enkele benodigde programma'tjes zelf heb moeten compileren.</p>
<p>Een kort voorbeeld van hoe je de repo van AttachFile zou kunnen gebruiken vind je in de versie van <a href="http://dev.budts.be/item/82">dit artikel op m'n Dev-Blog</a>.</p></p>