Older blog entries for async (starting at number 112)

Self-Control:

i've been trying to get a suitable version control workflow going: originally, i started with CVS of course, but moved to SVN when it became available. SVN was nice and has gotten nicer, having picked up an ssh-able protocol and a plain-file based backend. the one remaining issue for me is the lack of disconnected or distributed operation.

i gave Arch a try because all the other cool kids were jumping off the bridge, but i never really got into it. (though i must say arch, like svn, has come a long way (as jamesh pointed out to me)).

i found SVK a while back, which is a decentralized system that uses SVN's repository structure and the repository interface libraries. i only recently was able to get it compiled and running.

the setup i will start trying to use is something like this: a primary SVN repository will reside on a hosted server (though the repository isn't public). i then use SVK to mirror the primary repository to a local repository on my laptop/desktop and create a local branch. OK, AND HERE'S THE TRICK!! instead of using SVK to do all the version control on the local side (it has a slightly different working copy setup), i check out the working copy using SVN and use it as normal (well through the fantastic RSVN convenience wrapper (:D)). Finally i can use SVK again to star merge everything back to the primary repository.

the above mentioned trick is only to get around SVK being a bit slow-starting (written in perl) and the feeling that SVN's command-line client is more mature.

CACM has interesting article, News at 11:

September's CACM uncharacteristically contains some interesting content about end-user development (which i consider very important). it details some methods to create end-user programming interfaces that encourage testing, use of assertions, and ease fault localization. i've always found the HCI problems encountered in supporting complex tasks more compelling than the whole which-button-order and where-should-we-put-the-menu sorts of issues (not that they're not important, just that they're boring).

carry on.

BtYacc is the bee's knees! It is yacc but it can backtrack so it can handle conflicts.

this makes writing grammars much happier than using normal yacc: it allows you to write a grammar which more closely mirrors how one might think about the constructs of a language, rather than going through all manner of needless contortions to avoid conflicts. it also allows you to deal with garmmars that are inherently ambiguous.

BUT WAIT THERE'S MORE!

you only incur extra overhead compared to yacc when you actually backtrack.

9 Jul 2004 (updated 9 Jul 2004 at 05:58 UTC) »
on Eiffel

i've been messing with eiffel for the past week or so.

i think i like it, but i'm not sure. it is a substantial improvement over C++, but i'm not sure that's saying much.

getting used to eiffel has proved unsettling. i know a lot of languages coming from various design philosophies, so i didn't expect that i'd find it so jarring. it made me very aware that the languages i use regularly sharing some level of algol blood all look like C to one degree or another (in terms of nomenclature and syntax). perl and python and c++ all look roughly like each other if you squint.

on the other hand you have languages like APL and J which are easy to accept on their own terms because they don't look like much like anything else: you expect they'll be different.

eiffel though occupies a curious position [1]: even though i have experience with pascal and it's ilk, i found myself fighting to write C code (or C++ or python or perl code) in eiffel. i guess i couldn't decide if i wanted to dislike the language because of its resemblance to pascal and it's pedantic attitude ( not quite all the power of C along with lots of padding and helmets and gloves and disclaimers ) or to think of it as a tool providing features which naturally lead to software-engineering best-practices (ie it's not just C for the complete klutz like pascal). i decided to try to adopt the idiom rather than trying to fight it (certainly i would scoff at anyone trying to write C code in lisp).[2]

so i think i like it. especially for writing any code which is complex enough that you would want to sit down and design. [3]

regarding different languages, i like lots of different ones. this is sometimes distressing because i feel i should have a favorite that is 'best' and that i use for everything. but that's dumb. some are useful for different things (matlab v C), and some are useful for the same thing (python vs perl). i think all other things being equal (and i have the choice) sometimes i just want to write something in python or lisp or C depending on my mood or for a change of pace. and i think that's cool

so observations about eiffel

  • arrays starting from 1? dammit i spent 10 years in school to learn how to count from 0 and now you want me to count from 1? (matter of taste, but dijkstra showed that counting from 0 is in general more consistent. also screws with implementing numerical algorithms ; going against common practice increases the possibility for confusion though). (i bet there's some way to change this, since there is no special array syntax)

  • this 
       PROGRAM is do 
    	my_pants
    	hmmm_some_iteration_might_be_nice
    		iterate
    		end --
            huh
            yeah
       end --  program
    
    huh? i thought we all agreed that cobol is silly.

    (NB that code is a parody)

  • one class per file? are you some sort of nazi?
  • pre/post conditions - cool
  • you don't need parens for an empty arg list in a funcall...uhh how am i supposed to know it's a funcall? maybe if i start all the function names with '&'
  • !! is the new 'new' operator? so now you decide cobol *was* silly? also, saying bang-bang is fun.
  • locals declared in separate section? you're not my real father! *run to room slam door* *CRY*
  • 'functionname is do ... end'

    oh so that's where all the extra understood verbs from latin ended up.

  • /= is the new != ? 9 out of 10 cool kids agree: != is !=
  • explicit short-circuit boolean ops ('and then', 'or else') interesting, but a bit chatty.
  • := assignments: it's a pinky workout!
  • the compiler is not the gcc (which we know and love).
  • easy C usage ... cool
  • hmm the docs suck (they aren't organized well)... i guess i need to buy the book.
  • 'inspect foo when... when... else... end '

    ohh someone had their thesaurus handy. (though the switch and case of C never made any particular sense to me)

  • compilation looks at the entire program at once (which can do much better optimization of functions etc) -- yay, no more suffering the run-time inefficiencies of C to make writing code easier.
  • no header files: but how am i going to remember the members of my class if i don't type them out twice?
  • etc...

  1. i remember seeing a well circulated story on research showing that people find it easier to react positively towards visual representations of people if those representations are either completely unlike people or really close to people. however, those visual representations which occupy the middle ground of that continuum are more likely to elicit negative reactions.
  2. even though i still harbor some of the real-men-use-fortran attitude towards pascal, the punks in CS intro class who kept wanting to point out they knew C and complain that this is how things were done in C and why are we learning a useless language like pascal really annoyed the piss out of me: the class was in pascal, get over it.
  3. people calling themselves software engineers should be beaten daily. also i'd love to hear this out of an architect, "i would use it for any bridge that is large enough that you'd actually want to sit down and design it on paper first". i'm not trying to make an analogy or a point about programming (i like to hack and i think its ok though somtimes i miss noticing when a hack is big enough to require some planning and i don't know off hand how to do it). i only want to say 1. software engineers don't take the PE test and 2. taking statements from one context and putting them into another is sometimes funny.

  4. i *heart* run-on sentences.

You owe it to yourself to read these entertaining spams i received a few weeks ago.

for added fun and amusement i suggest doing a google search for this guy's other pages and reading them.

kaeru :

hi, i noticed your article on creating and applying patches. it looks helpful. one issue though: the output you show isn't a unified diff.

the output i get for your example is:

--- db.py       2004-05-20 05:46:43.000000000 -0400
+++ db-mod.py   2004-05-20 05:46:53.000000000 -0400
@@ -1,13 +1,13 @@
-        from pyPgSQL import PgSQL
+       from pyPgSQL import PgSQL
  
         ## note this code is for demo only, don't follow it :)
  
         def initialize():
             try:
                 db = PgSQL.connect (host='localhost',database='test',user='kaeru')
-            except connectionFailed:
-                print "This is a useless exception message and won't help you."-            return db
+                return db
+            except StandardError, detail:
+                print detail
  
         def getPlayers():
             db = initialize()

the unified meaning that both the added and removed sections are shown in the single listing.

unless i'm missing something.

you might consider expanding a bit on the -p option if you have time, since it gets a good amount of use.

thanks for the article; it's always good to have links to give folks on basic skills sorts of things.

elanthis: oh, i think i understand how you mean now. yeah i'd be interested to hear how that would be handled. sounds like funky graph theoretic stuff. maybe by keeping track of depth; it would only be a heuristic though.
elanthis :

some quick thoughts on your post.

you are thinking too much in the mode of C/C++:

if you want to signal that you have searched and not found an object you could return a pointer to the NULL *object*, for example (as in python, None). what good is that? well accidently using it may still be an error, but not one that will go unnoticed as can happen so often in C (with invalid references, not NULL ones, but the point would be that you couldn't have a pointer that is invalid here.)

as far as not having cyclic references, it would be enforced statically (at compile time). ie no expression where you create two strong pointers from one would be allowed. (not in C where you can turn a pointer into an int or have pointer aliasing).

doing garbage collection and handling scripting languages, you'd make the memory manager/allocator hold the strong reference i would guess.

i'm not saying that any of these are good suggestions, or that the ideas are good (though they are interesting); i'm just pointing out how you might do them.

yay i made new softwares:

rsvn is a wrapper for subversion which associates shorter and more easily typed names for repository URL's.

here is the web page: http://arcsin.org/softwares/rsvn.html

3 May 2004 (updated 3 May 2004 at 16:27 UTC) »
Join Ross
"Grab the nearest book, open it to page 23, find the 5th sentence, post the text of the sentence in your journal along with these instructions."

please don't turn this into livejournal. if i understand the purpose of the game correctly, it's to be able to say something when you have nothing to say. which is why you get all sorts of quizzes and random tasks like seeing what chain-restaurant appetizer you are on places like livejournal: many people there (and who use weblogs in general) don't have anything interesting to say.

i/we probably aren't so much above that level, but we can pretend.

at least make it an interesting or at the very least creative task or challenge, like perl golf, or using gimp to manipulate some piece of fine or pop-art into social satire.

citeseer

it seems it is fixed; yay!

HOLY SHIT THEY FUCKED UP CITESEER

103 older entries...

New Advogato Features

New HTML Parser: The long-awaited libxml2 based HTML parser code is live. It needs further work but already handles most markup better than the original parser.

Keep up with the latest Advogato features by reading the Advogato status blog.

If you're a C programmer with some spare time, take a look at the mod_virgule project page and help us with one of the tasks on the ToDo list!