Part 2

 

 

 

 

                                                      [Part 1 ]   [ Main ]

 

  Rooks

  In Fruit and Rybka, there are two main rook bonuses: open file and seventh rank. Open files are fairly simple, but have a rather uncommon  
  formulation that Fruit and Rybka share. Also, like mobility above, Fruit adds in a constant for every rook (to balance the open file scores  
  between positive and negative). This can be added in to the piece score, and can be ignored for the analysis here.

  In both Rybka and Fruit, we start by checking if there is a friendly pawn on the same file. In Rybka, however, we only check for pawns in
  front of the rook. This is a "semi-open" file. If there aren't any, we then check for an enemy pawn on the same file.

A quiz question. What's wrong with the reversed engineered Rybka code ?

It's:

 opening += RookOpenFileOpening - RookSemiOpenFileOpening; 
endgame += RookOpenFileEndgame - RookSemiOpenFileEndgame;

  Note that the compiler would merge "RookOpenFileOpening - RookSemiOpenFileOpening" into one value since both are declared as a CONSTANT. So
  where are these 2 constants (1035 and 428) coming from? They are not in the RYBKA executable, only the values 971 and 172 are. As confirmed by the
  assembler:

 RYBKA original ASM code 

  401b50: 48 85 05 39 ca 26 00 test QWORD PTR [rip+0x26ca39],rax
  401b57: 75 3d                jne  0x401b96
  401b59: 83 c6 40             add  esi,0x40  // 64
  401b5c: 81 c7 00 01 00 00    add  edi,0x100 // 256
  401b62: 4c 85 f8             test rax,r15
  401b65: 75 0c                jne  0x401b73
  401b67: 81 c6 cb 03 00 00    add  esi,0x3cb // 971 (1035-64)
  401b6d: 81 c7 ac 00 00 00    add  edi,0xac  // 172 (428-256)

  And thus Wegner in order to proof FRUIT code ASSUMED Constant Folding taking place as part of the Optimizing Process of the
  compiler ?

  In science, unfolding a constant "A" into "B - C" just because you assume it is justified, without any explanation, is literally,
  academic
dishonesty. In science you are supposed to present the data as it is, transparently.

 


 

  Unfortunately we are forced to stop here commenting Wegners document due to all the scrambling of the fonts, fontsizes and
  tables that took place during the conversion from PDF to HTML. Basically the HTML is hardly editable and the formatting takes
  more time than adding the comments.

  Nevertheless we think we have demonstrated that there is no single sign of code theft.

  Before we move to the more interesting document of Mark Watkins (as it does hint to code copying) we like to address one more 
  essential difference between the Fruit 2.1 and Rybka 1.0 EVAL namely that Fruit evaluates in 2 steps whereas Rykba directly adds
  to score. We don't understand why Wegner omits such a fundamental difference. One example of the many is found in 
  Fruit's EVAL.CPP

 FRUIT: EVAL.CPP -> LINE 655-682 
 op[me] -= RookOpenFileOpening / 2; eg[me] -= RookOpenFileEndgame / 2; 
op[me] += RookOpenFileOpening -RookSemiOpenFileOpening;
eg[me] += RookOpenFileEndgame -RookSemiOpenFileEndgame;  
 And later that op[me] and eg[me] are updated to the REAL evaluation variables: openingand endgame
 FRUIT: EVAL.CPP -> LINE 759-762 // update 
 *opening += ((op[White] - op[Black]) * PieceActivityWeight) / 256; 
*endgame += ((eg[White] - eg[Black]) * PieceActivityWeight) / 256;
 RYBKA just having: 
 opening += RookSemiOpenFileOpening; 
endgame += RookSemiOpenFileEndgame;
 Directly adding to the score. 
______________________________________________________________________________ 



 

                                                         Chapter II
                                                 Mark Watkins document

   Watkins on various places in his document hints to copy theft, we like to address these points.

  1. setjmp (idea borrowed from Fruit by the admission of Rajlich to unwind the recursive search) (elo gain 0)
    also found in other programs, for instance in Rookie by Marcel van Kervinck.
      
  2. Root search time control similarities playing apparent obvious moves (recaptures etc.) faster. (elo gain 1-2)
      
  3. Calling search from UCI (almost identical code) (elo gain 0) It's place is not so unusual as suggested, a
    version of Glaurung does it too.

    We don't consider these first 3 points as a sign of wrongdoing but your mileage may vary of course.
      
  4. More serious is Watkins accusation in Chapter 6.3.1 Parsing the "position" string. Please find our analysis here.
      
  5. We also researched Watkins accusation in Chapter 6.3.2 Time management. Please find our analysis here.
    It was disappointing for us to learn that the error with "0.0" was KNOWN by Watkins one year before the ICGA investigation
    started (2010) but was withheld from his document, withheld from the Panel and withheld from every forum discussion long
    after the ICGA verdict. For many programmers (Wegner included) "0.0" was an hot issue confirmed by the hundreds postings
    on this issue alone.

    We believe we convincingly refuted [4] and [5]. As such we believe the real evidence for code theft is extremely poor.

  As a final remark on this chapter we like to add it's not unlikely to assume Rajlich modelled Rybka 1.0 EVAL to Fruit.  
  There are signs for that and much of the contrary as demonstrated in this document. Probably the truth is 
  somewhere in the middle. The latter more or less confirmed by Rajlich himself, 3 weeks after the Rybka 1.0
  release (December 2005) in an interview his own words were: I took many ideas from Fruit. Also in the 
  documentation Fruit is mentioned as an inspiration source.

Special Thanks

I hesitate to include this section because I know I'll forget people who have been helpful in this project, but (with
advance apologies to the omitted) here goes:

Robert Hyatt - For Crafty. There is nothing like an open source program for passing knowledge to the next generation.

Fabien Letouzey - For Fruit, which shattered a number of computer chess myths, demonstrated several interesting ideas,
and made even the densest of us aware of fail-low pruning.

TordRomstad - For making Fabien aware of fail-low pruning :-), and more seriously for sharing in every way possible
his considerable knowledge.

Eugene Nalimov - For his cryptic but somehow fully functional endgame tablebase access code.

Uri Blass, Gerd Isenberg, Dieter Burssner, Vincent Diepeveen, Raschid Chan, Anthony Cozzie, Mridul M* :), Thomas
Gaksch, Peter Berger, SandroNecchi, Ed Shroeder, Amir Ban, Christophe Theron and every one else, past and present,
on the computer chess club: For sharing their computer chess knowledge despite the fact that in principle computer chess
is a competitive field.

Heinz van Kempen, Guenther Simon, Olivier Deville, Sergio Martinez, Claude Dubois: for testing early versions of Rybka
despite countless bugs and annoying problems.

Alex Dumov, Gabriel Luca: for helping a Windows newbie get up to around half-speed without excessive derision (or at
least open derision :))

and Iweta: for being great! :) and a pretty good Rybka tester and web master to boot

Happy testing, and best chess regards,

VasikRajlich

Budapest Hungary

December 4, 2005

 

 

                                                              Chapter III
                                                          External evidence

  Contrary to the ICGA press release which stated that Rajlich did not cooperate with the investigation Rajlich did
  offer cooperation and defence, see the email correspondence and offered the "Ponder-hit" defence.

  However Rajlich's defence was ignored and overruled by David Levy and Rajlich's defence never reached the
  Panel who was in charge of researching all evidence as stipulated by the Charter David Levy notable wrote himself.

 

  "Ponder-hits" and its twin "similarity tester" are 2 statistical tools that measure the move similarity between engines
  and especially the results of "similarity tester" are surprisingly because it produces a sorted list of all the known clones.
  And Rybka 1.0 is not one of them which confirmed our findings.

 


                                                                                            The evaluation originality test   
                                                                     Originality testing using Don Dailey's Similary tester utility
                                                                     60% and higher being a sign of non-originality,
                                                                     65% and higher being a sign of cloning.

Similary tester is an utility that is written by Komodo programmer Don Daily that measures the similarity between chess
programs. Each program has to analyze 8000 chess positions where multiple good moves are present and doing so basically a
 profile of the evaluation (playing style) of a program is made.
An example:


It's widely known that Loop and Onno are Fruit clones. Similary Tester reports as follows:

 Fruit 2.1

-----

70.81%

66.75%

 Loop 2007

70.81%

-----

68.56%

 Onno 1.04

66.75%

68.56%

-----

 

 

 

 

 

It's also widely known Houdini is derived from the Ippolit family. The statistic:

 

 Houdini 1.0

-----

67.27%

71.07%

 Ippolit 0.080a

67.27%

-----

69.31%

 RobboLito 0.09

71.07%

69.31%

-----

 

 

 

 

 

And now for Rybka, Fruit and Doch 09.980

 Doch 9.980

-----

51.58%

50.30%

 Fruit 2.1

51.58%

-----

54.43%

 Rybka 1.0 Beta

50.30%

54.43%

-----

 

 

 

 

 

  Doch 09.980 is Don Dailey's return to the computer chess arena in 2009 after a long absence, an engine (like Rybka) coming out of
  nothing with an incredible CCRL rating of 2970 elo. Both Doch and Rybka seem to have no connection to Fruit, they both are relative 
  safe and far away from the 60% gray area and only diifer a neglectful 3 percent in comparison with Fruit 2.1

  Furthermore both authors don't hide the origin of their success: the open-sources. From the Doch 09.980 README file we read:

                                        Also, much credit goes to the authors of open source chess programs.
                                         Many of the ideas and techniques for doch have been borrowed from
                                         these wonderful works of art.
  

  If Doch 09.980 is an original engine then so is Rybka 1.0 Beta.

  We want to emphasize that the last thing we want is to question is the integrity of programmer Don Dailey, we don't. The above
  information is strictly meant as another piece of counter evidence to unmask the ICGA verdict as a regrettable moment in the history
  of computer chess.

  Somehow (we believe) it's (still) not clear that the post-internet generation learns 10 times faster than the pre-internet generation
  because of the existence of email, open sources and computer chess fora which caused an explosion of knowledge and that
  therefore quick progress can be established without copying, as proven by many authors: Fabien Letouzey in the first place,
  Vasik Rajlich, Anthony Cozzie (Zappa) and lately Don Dailey (Doch, Komodo).

  Like Rajlich also Letouzey came out of nothing. Fruit 1.0 dates from March 2004, Fruit 2.1 is 15 months later and it took quite some
  known names by surprise.

  For more information about Don Dailey's Similary tester utility check out the study of Adam Hair on the issue how to detect clones
  and how well the software creates a sorted list of suspect engines.

 

                                                                  The Ponder-hit system
                                                                     The Rajlich defence

  Another way to test the originality of a chess program is the "ponder-hit" system as introduced by Kai Laskos, a computer chess
  theorist with statistical expertise who posts in the Talkchess computer chess forum.

  From a large volume of CCRL games the "ponder moves" were extracted from the PGN and collected in a similar way as Don  
  Dailey's Similary tester. And from the data (like in the Adam Hair study) a dendrogram was created.

  The picture tells the same story as Don Dailey's Similary tester, the same usual suspects and Rybka is not one of them. Loop,
  Toga and Onno being Fruit clones, Strelka and likely also Naum being Rybka clones.

                                                                The TOP-30 of Adam's study

Some additional notable pairs of engines (from the entire sample of 378 tested engines) not noted to be from the same family, with
the exception of acknowledged Fruit/Toga derivatives and Strelka (their inclusion is for illustrative purposes):

   1. Fruit 2.2.1        vs  Loop 2007          84.73% (similarity)
   2. Fruit 2.2.1        vs  Loop 10.32f        84.13%
   3. Strelka 1.8        vs  Rybka 1.0 Beta     73.11%
   4. Fruit 2.1          vs  TogaII 1.0         72.43%
   5. Fruit 2.1          vs  Loop 2007          70.81%
   6. RobboLito 0.085d1  vs  Houdini 1.00       70.37%
      ................
  29. Glaurung 1.2.1     vs  Alfil 8.1.1        59.47%
  30. Rybka 3            vs  Houdini 1.00       59.37%

 

 

      Note that Rybka 1.0 similarity to Fruit 2.1 is only 54.43% and is far away of the red zone.

 

                                               Chapter IV
                                         Historic evidence

History of cloning

1989 - Quickstep - Richard Lang clone (copyright breach)
1996 - Gunda - Crafty clone (copyright breach)
2002 - El Chinito - Crafty clone (copyright breach) Author admitted the wrong doing.
2003 - List - I leave this case out. Reul was banned but later reinstated.
2006 - Lion++ - Fruit clone (copyright breach) Authors admitted because felt they did nothing wrong.
2010 - SquarknII - Robbolito version with only 3 instructions changed.

All good decisions. All have in common that (source) code was taken as a whole and a derivative was the
result. In none of the cases the IGCA rule #2 and its interpretation became under pressure. Copying was
proven, end of story. A second
ingredient what they have in common is that all of them were easy to
debunk as a clone.

The pattern (easy catch) continues for engines that did not take part in ICGA tornaments, a known example is:

2010 - Houdini 1.0 - Derived from Robbolito. It took me one hour to spot that from the 2 binaries.

Robolito 0085e
0044903C aKingWhite1     db 'king white != 1',0 
0044904C aKingBlack1     db 'king black != 1',0 
0044905C aQueenWhite9    db 'queen white > 9',0 
0044906C aQueenBlack9    db 'queen black > 9',0 
0044907C aRookWhite10    db 'rook white > 10',0 
0044908C aRookBlack10    db 'rook black > 10',0 
0044909C aChiaroWhite9   db 'chiaro white > 9',0
004490B0 aChiaroBlack9   db 'chiaro black > 9',0
004490C4 aDarkWhite9     db 'dark white > 9',0   
004490D4 aDarkBlack9     db 'dark black > 9',0   
004490E4 aBishopWhite10  db 'bishop white > 10',0
004490F8 aBishopBlack10  db 'bishop black > 10',0
0044910C aKnightWhite10  db 'knight white > 10',0
00449120 aKnightBlack10  db 'knight black > 10',0
00449134 aPawnWhite8     db 'pawn white > 8',0   
00449144 aPawnBlack8     db 'pawn black > 8',0   
00449154 aPieceWhite16   db 'piece white > 16',0
00449168 aPieceBlack16   db 'piece black > 16',0
0044917C aPawnRankOneOrE db 'pawn rank one or eight',0
00449194 aCastleIllegale db 'castle illegale',0 
004491A4 aWhiteCaptureRe db 'white capture re',0
004491B8 aBlackCattureRe db 'black catture re',0
Houdini 1.0
aOneWhiteKingRe db 'ONE white king required',0 
aOneBlackKingRe db 'ONE black king required',0 
aTooManyWhiteQu db 'Too many white queens',0 
aTooManyBlackQu db 'Too many black queens',0  
aTooManyWhiteRo db 'Too many white rooks',0 
aTooManyBlackRo db 'Too many black rooks',0 
aTooManyLightSq db 'Too many light-squared white bishops',0 
aTooManyLight_0 db 'Too many light-squared black bishops',0 
aTooManyDarkSqu db 'Too many dark-squared white bishops',0 
aTooManyDarkS_0 db 'Too many dark-squared black bishops',0 
aTooManyWhiteBi db 'Too many white bishops',0 
aTooManyBlackBi db 'Too many black bishops',0 
aTooManyWhiteKn db 'Too many white knights',0 
aTooManyBlackKn db 'Too many black knights',0 
aTooManyWhitePa db 'Too many white pawns',0 
aTooManyBlackPa db 'Too many black pawns',0 
aTooManyWhitePi db 'Too many white pieces',0 
aTooManyBlackPi db 'Too many black pieces',0 
aPawnAtRank1Or8 db 'Pawn at rank 1 or 8',0 
aIllegalCastlin db 'Illegal castling',0 
aBlackKingCanBe db 'Black king can be captured',0 
aWhiteKingCanBe db 'White king can be captured',0


  It's this kind of undeniable DNA traces that are left to trace a derivative, even the order of the error messages remained
  fully intact. This aside the evidences other people reveiled about the origin of Houdini.

  The lesson that can be learned from history is that cloners leave (obvious) DNA traces. And such obvious and undeniable
  DNA traces were not found in Rybka 1.0, see Chapter II.


                                                                 Chapter V
                                             Additional evidence of Rybka originality
                                                                                                          September 2013

When we in September 2012 presented this critical document to various key people of the ICGA it was met by
silence until this present day despite various reminders
.

 

Instead, in 2013 the ICGA released another opinion rehashing its (old) arguments from 2011 and virtually ignoring
the detailed critique of its evidence.

 

A quote

 

           We repeat from Section7.2 the summary of this part of the report:  ...nearly the entire

           evaluation function is derived from FRUIT. This includes the formulas for calculating piece- square

           tables,methods and features of evaluating piece mobility,rookkingfileproximity, rook and queen

           on the 7thrank,and king safety.

           

           We leave it to readers to study the evidence presented in the investigation report, in Riis's

           article and in Mark Watkins (2011) rebuttal, and to decide for themselves who they believe.

 

          End quote

            

          Unlike the ICGA Rybka investigators (Zach Wegner & Mark Watkins) our own investigation highlights

          many important points that Wegner and Watkins missed, such as errors in the reversed engineered

          material of which some were deliberately withheld from the documents and information by Rajlich

          that deliberately was withheld by the ICGA to the investigation Panel.

 

          Aside from that, whereas the ICGA Rybka investigators could only find 5-7 differences

          between the evaluation of Fruit and Rybka, the contra investigation shows a long list.

 

         In short:

 

         Every major evaluation ingredient is coded differently, mobility, king safety, passed pawns,

         double pawns, backward pawns, Rybka is missing Fruit's late endgame knowledge, Rybka

         has a material table different from Fruit.  Rybka does not contain Fruit's quad function,

         Rybka's trapped bishop evaluation is different, rook evaluation is different, bishop pair

         evaluation different and most importantly, Fruit evaluates in stages in a unique way

         whereas Rybka adds directly to its score (as every other program on the planet does).
        

         Another difference is that Fruit evaluates the white & black pieces in one block of code

         whereas Rybka evaluates in 2 separate blocks of split code.

        

         Other (minor and key) differences between Fruit and Rybka:

         1. Time control is different
         2. Fen parsing is different
         3. Rybka extracts the mainline from the TT, Fruit via the classic triangle table
         4. Rybka 1.0 beta displays a mainline of max 10 plies, Fruit produces much longer variations
         5. Rybka uses a bitboard board representation whereas Fruit is mailbox
         6. Rybka's pawn value is 3200 (which is unique), Fruit uses the classic value of 100.
         7. The order in the evaluations of Fruit and Rybka are not similar
         8. Rybka has lazy evaluation, which is absent in Fruit
         9. Futility pruning is different between the two programs
       10. Rybka uses Late Move Reductions (LMR) whereas Fruit uses history reductions
       11. Fruit uses a history table which is absent Rybka.
       12. Fruit only has one evaluation table (king safety) while Rybka has many.
       13. Rybka does not handle promotions to minor pieces

       14. The two programs have a different move format
       15. The two programs have different hash table code
       16. They have different handling of repetitions and the 50-move rule in search
       17. Fruit maintains piece-lists which are not present in Rybka
       18. Fruit maintains a pseudo "bitboard" for pawns, Rybka has the real thing.
       19. Contrary to Fruit, Rybka needs to update 4 rotations of occupancy bitboard.
       20. Contrary to Fruit, Rybka updates a rough estimate of material balance with weights of

             1:3:3:5:10 (in the evaluation this value is then corrected by a delta obtained from the

             material table)
       21. Fruit has a 16*16 square mailbox, Rybka has an 8*8
       22. The programs have different Zobrist hash keys

       23. The programs have different user interface options

     

       We found 36 indisputable differences (some of which are very fundamental), not counting the

       ones that are debatable such as the PST's and the contents of the TT. 

       Why didn't Wegner & Watkins come up with this list but only found 5-6-7 differences?

       And if Wegner & Watkins had researched the Rybka 2.3.2 version, the one that actually played

       in an ICGA tournament (and not Rybka 1.0 beta) they would have found that the list of

       differences was much greater.

 

       Mark Watkins - I think the case for "copyright infringement" (or plagiarism) of the evaluation

                                 function as a whole is quite weighty, particularly when combined with the

                                various other Fruit 2.1 bits that appear here-and-there in Rybka 1.0 Beta.

      So by the standard of Watkins we need to judge the contra evidence as a whole (36 points)

      too and the accusation that Rajlich copied Fruit becomes less and less plausible the longer the

      list becomes.

 

      Further "remarkable" statements of the two ICGA Rybka investigators:

 

      Mark Watkins - The Rybka 1.0 Beta executable contains no literally copied evaluation code from

                                Fruit 2.1.

 

      Zach Wegner   - Coming back to Rybka/Fruit, yes, if you look at each example in detail, you

                                can't say there is much hard evidence of direct code copying. As I said to Vas,

                                I'm only completely certain that three characters were copied ("0.0").

 

      Conclusion    - If verbatim copying can not be proven and the accusation stands or falls with the number
                               of similarities while after close inspection many of the alleged similarities are differences
                               after all as pointed out above and throughout this whole document then the accusation itself
                               loses credibility up to the point one should question if the burden of proof is sufficient enough
                               to ruin a man's reputation and carreer. 
                             

 

      Note - The credit for points 14-21 goes to Richard Vida author of Critter when he was asked
                  to 
reverse engineer parts of Rybka 1.0 beta that Watkins and Wegner didn't research.

 

      Note - Please find our answer to the ICGA (2013) document here.

 

      

 

                                                                                Chapter VI

                                                   an experiment

 

     Somewhere in 2012 Mark Watkins and I agreed to an experiment. I proposed Mark to take the

      Fruit source code and change all evaluation values to Rybka values, then measure the percentage

      difference with similarity tester. Watkins took the challenge and reported a 4% increase.

      From Zach's document - Simply put, Rybka's evaluation is virtually identical to Fruit's.

      Meaning, if we give Fruit (or Rybka 1.0 beta for that matter) all the same evaluation values then
      (using Zach's words) Fruit and Rybka are virtually identical. Naturally Watkins liked the idea, enough
      for him to put considerable time in the idea, for me the outcome was quite an important moment.
      If suddenly similarity tester would report sky-high numbers then certainly I would have to rethink
      my position from scratch.
       

      And the Rybka-Fruit similarity went up from 54% to 58%.

      Now 58% similarity is a very poor number for 2 identical evaluations.

      If we take the 58% and compare it with Adam's clone study it doesn't even make it to the top-30
      of the suspect engines list.

   1. Fruit 2.2.1        vs  Loop 2007          84.73% (similarity)
   2. Fruit 2.2.1        vs  Loop 10.32f        84.13%
   3. Strelka 1.8        vs  Rybka 1.0 Beta     73.11%
   4. Fruit 2.1          vs  TogaII 1.0         72.43%
   5. Fruit 2.1          vs  Loop 2007          70.81%
   6. RobboLito 0.085d1  vs  Houdini 1.00       70.37%
      ................
  29. Glaurung 1.2.1     vs  Alfil 8.1.1        59.47%
  30. Rybka 3            vs  Houdini 1.00       59.37%

     The logical question here is, how can Zach's statement - Simply put, Rybka's evaluation is virtually 
     identical to Fruit's
possibly be true?

 

                                       A thought experiment
                                       the 5.5 month dilemma

Although the ICGA verdict does't dare to state literal copying and only refers to plagiarism it's generally assumed
and no big secret the majority of the guilty voters meant the verbatim copy+modify = derivative model of Fruit 2.1
as can be read in the Fabien complaint to the ICGA and is demonstrated openly by Fabien himself, Zach Wegner
(see section Pawn Evaluation), Robert Hyatt, Mark Lefler (ICGA secretariat) in public statements.

For them (and experienced chess programmers in general) we like to point to the following dilemma. Fruit 2.1 was
released on June 17, 2005 and Rybka 1.0 beta on December 4, 2005. That makes a difference of 5.5 month.

Consider the timeframe, to do all this (the copy+modify accusation) Rajlich had exactly 5.5 months, removing all
Fruit 2.1 DNA (check Chapter V what that effort means), making all the small and big changes (same Chapter V),
mailbox to bitboard to begin with, all the debugging, all the testing, adding 100 elo in the process.

How likely is this 5.5 month scenario?

 

                                           Conclusion
If verbatim copying can not be proven and the accusation stands or falls with the number of similarities while after close
inspection many of the alleged similarities are differences after all as pointed out in Chapter V  and throughout this
whole document then the accusation itself loses credibility up to the point one should question if the burden of proof is
sufficient enough to ruin a man's reputation and carreer.

We like to end with some snippets of Fabien's own words 2 months before the Fruit 2.1 release, see chapter Introduction.

  • But there again the evaluation features are hardly ever very original: the principles of sound chess play
    can be found in hundreds of books.
     
  • OK let's stop here and do a little sum up with Fruit in mind: I can't think of a search feature in it that
    was not described before. Ditto for evaluation terms
     
  • Can I claim that I have written it all on my own? "Yes", I typed all the code myself. Without help???  
    Certainly not, hence my point: "it makes no sense".
     
  • People can find ideas (with no guarantee) or simply discover a "different" programming style.
     
  • It's about freedom.

 

                                                                                [Part 1 ]   [Main ]