Programming

by

You know, if it wasn’t for having to read things like ToLongADamnTypeName toLongAVarName = new ToLongADamnTypeName() like constructs in all three languages, I could really get to like C# for cross platform work.

^_^ If only because Novel(mono) and Microsoft have each produced C# compilers that are 100 times faster than Suns javac, while still compiling faster than many C++ compilers. ^_^

github and filter-branch fun

by

In between being driven crackers, I’ve been *attacking* just about every TODO and item in my backlog. Staying insanely busy has the benefit that there’s minimal time to feel or think, until passing out cold >_>.

Except for a minor issue with power save, and tools for a couple programming languages to be installed, work on my laptop is virtually complete.
One thing I have finally accomplished is preparing my personal git repository for the hub. For almost two years now, I’ve kept the important stuff in my home directory under revision control. Now I at long last have an off-site backup of it, reduce need for pastebins, and I could care less if anyone finds the repo helpful 8=). I’m more concerned about freak system failure here… lol.  Somethings, like my vim files represent like 4 years of work so there is a wee bit of life/time investment here.
Projects get their own repositories as needed but top level stuff in $HOME shares one. Originally I used CVS, since my file server only came with that and RCS, and I didn’t want to bloat it with Subversion. About five months later, I switched to git ;).
Here things are still very simple. The file server has a mirror of any important data, plus it has bare git repositories for various projects: backed up independently of my personal data. Plus project repos on several hosting sites.  It’s good insurance: now my most important files have the same.
And of course being me, it’s obvious that I generated a patch set and skimmed through the 17,000-18,000 some lines of data representing over 200 commits, before I would allow the repo to get pushed into a public place.  I tend to be cautious in what I commit, to much so in fact. This repo however was always meant to be “Private”, and programs sometime become probmatic. I only found one instance where this was a concern, minor but still rather something that should be compromised.
The solution of course is to just rewrite history:




$ git filter-branch –tree-filter ‘git ls-files -z “filename glob” |xargs -0 perl -p -i -e “s/secret stuff/Censored By The Git History Cops!/g”‘ — –all




$ git gc –aggressive –prune




$ git push –force origin




$ git remote add github git@github.com:Spidey01/Terry.git


$ git push github master








Also being myself, I made sure to first test the filter-branch in a fresh clone into /tmp, back up my .git directory, as well as verifying the log and format-patch output that it worked. Plus since I made a tag of a commit before updating master to reflect it’s current machine: I also made sure to check that the tag remained unchanged from the filter-branch.








and now… I’m to darn tired to do more than pass out.

			


					
			





	

					

						

			 by  		

					

			
			

				
To say that I love using git for managing source code, would be the understatement of the year.


The first tool I used was Subversion (around late v1.4/early v1.5), and I rarely had any trouble using CVS either. I can basically pick up and figure out any tool given a decent manual or enough kick around time.


It’s like having a freaking swiss army knife of managing changesets, having git in hand :-S

			


					
			





	

					

				
This really did make me laugh out loud
		

			 by  		

					

			
			

				
“If I had a nickel for every time I’ve written “for (i = 0; i < N; i++)” in C I’d be a millionaire.”


– Mike Vanier






Even more so because for stuff I’ve in mind to write, involves noting that inescapable fact of C programming :-o.

			


					
			





	

					

						

			 by  		

					

			
			

				
Today I’ve had to get used to living with Subversion again, as much as I simply love git, setting up a repository is easier with svn then git-svn :-S. Aside from the obvious problems that chop up from their different mental models it’s not that bad.


The lights flickering as the thunder blares outside on the other hand, tell me that I should probably *WAIT* to merge this vendor branch into the trunk – and go look up how atomic svn copy src-url … dst-url actually is in terms of network and power failures! If I was using git I would just say screw it and do the merge, because I know already that git doesn’t phone home to the repository, because the working copy is a repository.


Oh well, to the manuals!

			


					
			







	

					

				
How I tend to build projects, or why it’s usually painful on build tools
		

			 by  		

					

			
			

				
I’ll typically setup what I call a tripple-tree, or a quad-tree layout. Each project has three top level tree structures that represent a phase of “Getting it done”. Hacking it, building it, and distributing it.


A source directory (typically src or Source), that houses  the projects code, and basically everything you/I want under version control. Structure varies but I tend to create modular bundles out of habit.


A build directory (typically Build/Architecture/OS or Build/Architecture.OS), that houses all essential build time files for that configuration, that won’t be distributed. I test builds against multiple Operating Systems, and synchronise the work directory between machines; so being able to have builds of each concurrently tucked away is a bonus. Sometimes I go further and subdivide the build tree into different configurations, such as Release/Optimised/Debug builds, but I rarely have need to.


A distribution directory (typically Dist/Architecture/OS or Dist/Architecture.OS), that contains all the files needed for a user to simply extract to a folder on that given system, and run the program. Worth while for me, for the same reasons as the build tree, plus the added benefit of simple a zip/tar installation!


Sometimes I also create a fourth tree called ‘Vendor’ or ‘Deps’, that functions like the source tree, but instead contains the code for whatever libs are required. Plus customised project files/build scripts to compile them when needed.




Like wise, I’ll often have an associated set of FILES in the top level, and a documentation directory providing all pertinent information. I particularly pay attention to writing down notes about boot strapping builds, and porting the system to a new environment; because you never know when the next sap sending patches will be you.




Oh so many people ship IDE project files that reek of laziness or brain damage. Me, I’m so damn lazy that I don’t want to have to explain it, in fact, I don’t even want to edit it later. I just want the thing to *work* when I tell it to build sth. It takes time to do it that way, but it is usually worth it. At least, for cross-platform freaks like me.


Programming is a subject that I do take seriously.

			


					
			





	

					

				
Quick & Painless C/C++ header installations using rake
		

			 by  		

					

			
			

				
In wrapping up and refactoring my new rake driven build system, I’ve written numerous utility functions. Most stuff specific to compiling crap is in a custom “Builder” module that provides a templated interface to the current OS/Compiler kit, via environment variables and methods like make_object, make_shared_library. My top level rakefile also has a neato inference rule rigged together for handling my triple-tree and quad tree build patterns.


The real fun of the day however, is this baby:





#
# A magic function that generates file tasks that copy all headers from
# directory ind # to directory outd.  Any missing directories are created as
# needed.
#
# The return value is a list suitable for the right hand side of a task, e.g.
#
#   task :headers => header_magic(src, dest)
#
def header_magic(ind, outd)
  dirs = []
  hdrs = []

  find_files(ind, /.*.h[hxp]*$/) do |p|
    outdir = File.dirname p.sub(ind, outd)
    outfile = File.join(outd, File.basename(p))

    directory outdir
    file outfile => p do
      cp_r p, outdir
    end
    dirs.push outdir
    hdrs.push outfile
    CLEAN.include outfile, outdir
  end

  dirs+hdrs
end




find_files is another custom function, it simply takes a block and yields and file names matching the specified pattern. (In this case, more liberal than the usual header extensions but sufficient for my needs)






I call it header_magic, because it after all the other stuff I played with, it’s the closest to Clarke’s third law. Which is exactly what I want!








footnote: I just have my top level clean task nuke the entire build tree; so the CLEAN part hasn’t been tested.