mac dev news

10.2.1: addn/dev.mac


news.addn/dev.mac#iphone/acceptance science:
. I read the following site to remind me of
things to watch out for when submitting:
Avoiding iPhone App Rejection From Apple
And I read to remind me that many developers are frustrated with apple:


bk.addn/dev.mac/Cocoa Programming Developer's Handbook(free chapter):
David Chisnall goes through the most important aspects
of the OpenStep Foundation framework.,
which covers the core functionality of the Cocoa development environment.


proj.addn/dev.mac/obj'c/text errata:
. must be for the old version of the book I have;
all these corrections have been made in my edition .


proj.addn/dev.c/vc++ code editor: has code folding (yum) .



While Cygwin would be an obvious choice for
many Unix/Linux power users,
there is an excellent and a much simpler
alternative to using Cygwin
is using GNUWin32's coreutils .
. looking into that huge gnu collection
I notice he has indeed vastly simplified things
by getting just one of among dozens of packages .
. getting the entire gnuwin32 collection
would be as complicated as cygwin
and for that case, they use cygwin's approach:
an installer app that gets the latest version of each package .
. reviewing the code,
I see it's nicely commented,
but some can seem overly complicated by the use of
conditional compilation directives .

. Chapter 1: Introducing Pylons — Pylons Book v1.1 documentation


sci.addn/dev.mac/accessability example:
. their example comes as a before&after version of the same project,
and I'm using winmerge to see the diff's side-by-side .

2.15: web.addn/dev.mac/cocoadesignpatterns.com:

Cocoa Design Patterns By Erik Buck and Don Yacktman

Sample Code
Voices that Matter
Materials from Erik's talk at the Voices that Matter - iPhone Developers Conference
CocoaDesignPatternsSampleCode.zip (1.3M)
Sample Code for Cocoa Design Patterns.


Sample Code > Voices that Matter
Cocoa Design Patterns.pdf (2.7M)
GLGravityToyPlane.zip (6M)
OpenGL ES for iPhone Games.pdf (1.6M)
Transparis.zip (239K)
Transparis3D.zip (243K)
Transparis3DCoreData.zip (289K)


2.17: web.addn/dev.mac/cocoa patterns ref's to stepwise:

see cocoa page 111 for todo.web.

I just read the new article on Stepwise about Cocoa
memory management by Manu Iyengar

(which is very well done, by the way). In it, he presents the
following code as a useful idiom for writing set accessor methods.

> - (void) setTheory: (Theory *)newTheory
> {
> Theory *oldTheory = nil;
> if ( theory != newTheory ) // If they're the same,
do nothing
> {
> [self willChange]; // For Enterprise
Objects only
> oldTheory = theory; // Copy the reference
> theory = [newTheory retain];// First retain the new object
> [oldTheory release]; // Then release the old object
> }
> return;
> }

I'm new to Cocoa and I'd like to adopt as many useful idioms as I
can find. There seem to be many with regard to writing set accessor
functions...;-) What are the pros and cons of the code above
compared to other set accessor idioms I've seen, like this:
- (void) setTheory: (Theory*)newTheory
if ( theory != newTheory )
[theory release];
theory = [newTheory retain];
William Garrison wrote:
> (snip)
>In particular, why would I want to create a temporary pointer to the
>existing ivar value before setting it to the new value? Manu's
>example uses a basic swap pattern, but I don't know why that would be
>useful. Why can't I just release the existing ivar object and then
>retain the new value, as the second code example does?

Multithreading. There's a very small but still very real chance that
the current thread might be switched between the release and the new
assignment, so another thread might try to access the just released
(and maybe deallocated!) object and go boom
Alternatively you could use a simple lock but that's overkill for
the 99% percent when you don't need it.

>Would using autorelease instead of release be another way to protect against
>this? After all, the old object wouldn't be up for a real release until
>after the new object is retained.

Sure, but then you'd have to pay for the autorelease each time, which
is much more expensive than a second reference (memory and cycles-wise).
There ain't no free lunch. :)


lib.addn/dev.mac/www.stepwise.com articles archived:
. site:www.stepwise.com/Articles was not easy to find before,
but did ok this time:
. HoldMe.html is the mem'mgt tutorial recommended by buck`patterns .

proj.addn/dev.mac/doc's copied to xpw:
. explore mac's dev/doc's ...
can't find as expected?
because, they seem to be in a special archive format:
use downloads instead:
. zip cocoa doc's to xpw (the downloaded pdf's) .
. by context menu this is seen as a type of folder;
everything is html .

2.25: aq.addn/dev.mac#iPhone/app review/CrazyMikesapps.com


2.23: adda/oop/child pkg's similarity to subclasses:
. child pkg's are like subclasses
so how does ada handle choice of visible to public,
subclasses, self-only?

adda/oop/freedom with security:
. encapsulation means not having the freedom to
poke into privates .
. one way to have freedom too,
is using the unix idea of root user:
encapsulation can be broken in root.user mode .

mem mgt

2.18: adda/mem mgt:
. one way to handle dangling ptr's is
have pointer be to a ptr var that
holds the ptr to target value (ie, sharers are handles)?
if there's a chance that var will be dealloc'd
then must have a global place for sharables .


adda/mem'mgt/cyclic structures:
. one way to handle cyclic graphs
is have each node carry an [has been copied].bit
and copy recursively whenever that bit's not set .

goto variables

2.14: adda/translate/cstr/goto variables:
. labels targeted by {enter, exit, goto}
are constant versions of the goto variables;
ie, label.to: here
is the same as label.to`= here
except that the colon syntax gives it a value it must keep .
. a goto label is assigned the place it's declared at:
here.to: v.to`= here;
-- the variable v is assigned the constant here .
. when translating to c,
which supports only goto /constants/
-- not goto /variable/ --
the .to var must be impl'd as an enum
whose values include all of a scope's
constant .to labels,
so then a ( goto /var/ ).stmt
would be translated as casing the enum,
and mapping each enum to a constant goto label;
enum places {toplace1, toplace2, ...};
places mygoto;
mygoto = toplace1;
switch mygoto
{case toplace1: goto place1;
case toplace2: goto place2;
... } .

vector syntax with dot for clarity

2.14: adda/dstr/vector syntax with dot for clarity:
. could this:
work like this?
. it may conflict with other (misplaced) ideas,
but would make it easier for the compiler
to tell when (<) was starting a <,,,>
and not a [less than] operator .

c's case fall-through

2.14: adda/cstr/c's case fall-through:
. if the case src is a set the case should do
multiple things (concurrently?) .
. to provide c's case fall-through,
it should use the (enter [/]case).stmt .
. will case labels conflict?
the users know what literals they're casing,
and they can choose goto labels that don't conflict;
but what about nested cases?
to jump from one case stmt to an enclosing one,
use a goto label
or use ../case ?

selection stmt minimalized

2.14: adda/cstr/selection stmt minimalized:
. can terminator of selection.stmt be (;)?
you can explain that
? ,,, ;
is an enclosure similar to
.. the problem with that is a very unexpected
piling up of ;; when things get nested .
. notice too that commas could be replaced with
the case key:
e ? case1: e case2: e;

obj'c`categories vs ada`child pkg's

2.14: adda/cstr/obj'c`categories vs ada`child pkg's:
. obj'c`categories like ada`child pkg's ?
categories are more modifiable:
you can override old def's
even without a recompile of old clients,
because classes are linked at run time, not compile time .
. pkg's are hardwired
but the compiler keeps a record of how
compilation units are org'd,
and this record can be modified,
so a parent pkg body
stays uncompiled and un-overridden
while a parent pkg head
can have child pkg's appended to it .

compressing names

2.12: mis.adda/compressing names:
. not sure where I'm going with this;
may want get through a book of algorithms first .
. a sha1 converts a file into a practically unique number
wondering what the conditions of that are
and how it could be of use for creating name id's
. if any user name could be mapped to something like an 8byte number,
then that would make storage of names much more efficient .
. the lookup would not be as quick as a hash;
it would use a binary search ?
. compilers use hashing to help them place a found string into a symbol table;
hash converts the string into an byte,
and then instead of putting it in a bucket,
it can add on some more bits to make it unique .
. when that string is found again,
the hash quickly finds the approximate location .
. hashing would also be used for huge symbol tables
like the one converting all words to wordcodes .
. hashing is a much less expensive version of sha1
(sha = Secure Hash Algorithm)

oop'ish return param's

adda/translate/oop'ish return param's:
. to promote a system that includes both exceptions
and that simplifies garbage collection for functions,
all adda functions should be impl'd as procedures
in which one of the param's is expecting a pointer to
where the return should go .
. any function f:x->y
is translated in c, then,
to f: (x, rtn.ptr.out) -> exception code .
. a common problem found in oop lang's,
is keeping track of who's responsible for
deallocating an object;
the primary reason for this is an efficiency trick:
. every oop value is, for the sake of modularity,
represented by a dynamically allocated obj'
(a pointer out to some place on the heap) .
. when wanting to send a value,
the modular way is to copy the value,
and send that copy's pointer;
but the efficient way is to minimize copying of values,
by copying and sending pointers
so there are multiple pointers
sharing the same obj' representing a value .
. however,
now there has to be a system for knowing
whether an obj' is being shared or not;
because if it's not, and you have the only pointer to an obj'
then you should deallocate the obj'
before you dealocate your pointer to it .
. conversely, if the obj' is being shared,
then it's important that you not dealocate the obj'
because that would leave its other pointers dangling .
. another source of sharing is not efficiency
but just because the routine way to operate
is to have a function accept 1 or more arg's
and then return a value to some other obj' .
. to avoid this case of unnecessary sharing
a function that is not sharing
should indicate so requesting one of the parameters be
a pointer to an obj' owned by the caller,
so then the caller knows in this case
that it owns the obj',
and will be the one to deallocated it .
. yet another cause of uncontroled dealloc's
is when the function is returning the value to an assignment,
which in many bolt-on versions of oop,
means the function is wiping out a pointer
that the assignment's destination.obj was already holding .
. the way around this is to not use the usual
assignment.stmt(dstination.out, src.in)
and instead have each type`mgt
define its own assignment dstination.INout, src.in)
which asks that the param' for the destination obj'
be of mode inout so that
not only can the destination be written to,
but it can also be read, and with that reading,
the destination's current pointer can be deallocated by
the assignment operator .
. it would be a lot easier to get more out a c compiler
if adda functions did translate to
similar functions in c .
. there does need to be a param
for caller to say where to put the return;
but, the retun should be passed by return vs out.mode param .
. a recent note thought exceptions could be done through the return,
but prior notes had ways that used globals .

nested subprograms

2.4: adda/nested subprograms:

. nested sub's have 2 special properties
(2 reasons why they should be nested):
the nestedSub' may be so specialized
as to be of use only to its ownerSub';
in this case,
nesting restricts the nestedSub's name
to the ownerSub's namespace,
so as to not clutter up the global namespace .
. another special property of nesting
is that a nestedSub has access to the locals of ownerSub,
which practically means that a call to nestedSub
needs a pointer to the caller's act'rec .
. this involves a form of generics:
it's being owned by a function class whose members are
sharing the same function definition
but are distinguished by having separate act'rec's .
. assuming a nestedSub does access some ownerSub`locals,
then each ownerSub instance needs to set up a record
containing pointers to the needed locals,
and then pass that record with each call to nestedSub(x) .
. say the record would be called [shared with nestedSub],
then each call would be:
nestedSub([shared with nestedSub], x),
. a nested generic is requiring 2 layers of instantiation:
being nested requires a partial instantiation
that defines who the current owner is,
and then the owner can set up
numerous instantiations of this owned generic:
nestedGenericSub([shared with nestedSub], [genericInstanceSub`args], x) .



. what does ada's generic look like as c code?
it's typically a function call that returns a subprogram:
. subGenericInstance`= genericSub(instantiation param's)
. it's setting parameters that will be used by
every subsequent call to subGenericInstance .
. when the generic's param is of type "(type),
that is translated using the fact that
types can be expressed as a collection of pointers to
the operations that impl' that type .
eg, if there exists genericSub(number.type)
then the actual param can be any type that
supports the bi'ops {+, -, *, /}
and the uni'ops {-, /} .
. ada generics, due to efficiency concerns,
likely involve some additional semantics .

2.4: translation to c:
. generics can be instantiated numerous times;
each instantiation means setting up a record
containing pointers to generic's instantiation arg's,
and then passing that record with each call to genericInstanceSub(x) .
. say the record would be called [generic instantiation#n's arg's],
then each call would be:
genericInstanceSub([generic instantiation#n's arg's], x) .

. if the generic is a package instead of a sub',
then it practically means
the package includes both its own components
plus its generic instantiation record .

. a generic instantiation is considered to be first-class,
when it can be treated like any other subprogram;
for this to occur,
a sub', which is usually represented by a pointer,
must include along with that pointer,
a tag indicating whether it's nested,
and whether it's generic
(each means 1bit of the tag) .
--. if c has some restrictions about function typing,
then all dynamic functions can be impl'd as
unary or binary operations over etree .

. one of the struct's fields is a pointer to a callable generic .
. this is not really needed because it's statically known
but part of supporting reflection is that
instead of there being just function pointers,
there is an id bundled with the pointer
so that the program has access to the name of a function
along with details known statically about the function
like its signature (req'd param`types, and provided output`types) .
. along with a function'id is the environ.ptr,
for cases where the function is declared nested .
. the generics.ptr
-- for cases where the function is generic --
is pointing at the generic's instantiation record .

how does adda define a generic?
they are functions returning some cstr,
typically a function .
their param's can include types (sets of function ptrs) .
G(T).(X).Y; -- G is a generic returning a sub' of type (X).Y
f(x).y: G(t) . -- f is a constant function
defined as an instantiation of G .
neat.type: (x).y; -- "(neat) is a constant type name for (x).y .
G(T).neat; -- G returns a function of type neat .
f.neat: G(t) -- f is a constant function
defined as an instantiation of G .

. to become familiar with subtleties of generics,
need to see examples of them in c++ and ada .

adde accessability

2.11: web,sci.adde/blind assist/what jaws can work with:

sci.adde/blind assist,
web.adde/blind assist/mac's accessability framework

founder of Technologies for the Visually Impaired
talks about switching to mac
says (not exactly fun) but mac is unfairly condemned by
September 2005 issue of Access World
. the store he found includes brail displays,
so in this case, a simple gui or tui could be useful .

Introduction to Accessibility Overview

Don’t override built-in keyboard shortcuts. (listed in the Apple Human Interface Guidelines
appendix “Keyboard Shortcuts Quick Reference”)
and to the accessibility-related keyboard shortcuts
(listed in “Accessibility Keyboard Shortcuts”).

This chapter introduces the accessibility protocol. It describes:
The model that represents accessible applications to assistive technologies
The accessibility object that represents user interface objects
Some of the ways an assistive application interacts with an accessible application
If you’re an application developer, you should read this chapter
to learn about the Mac OS X accessibility protocol.
Then, if you’re ready to access-enable your application,
you should read Accessibility Programming Guidelines for Cocoa
or Accessibility Programming Guidelines for Carbon.


. for those using JAWS for Windows,
GTK/Tkinter impl's are incompatable;
need to use windows forms
as provided by WXPython (or any other WX equivalent),
or standard Windows controls,

. after looking at the output from hg's cli,
I got the idea that for the audio version
one annoyance to be avoided
is having the reader read everything on the screen .
. the pattern with tool outputs,
is that it's a record with named fields;
and you should be given a chance to customize the reading .
. it may already have things like tabbing .
. checking the mac options, they are the built-in voiceover,
so the first path is just making sure you stay voiceover-friendly .
. the next path is to have app's that are meant to be displayed in audio .
. addx uses the mvc pattern,
separating the model from the presentation,
but to make it easier on the programmer,
there had been the idea of implicit inout
where the program just had to present the data as an interface,
and then the user would choose between tui or gui .
. both of those are visual,
so I had implicit assumptions about mapping data to visuals;
ie, the standard datastructures and types
would all have visual representations .
. the primary need from an audio representation
is that all components have brief descriptive names
and then the main mode would use fieldname traversal
along with arrows, tabs, and enter to get in or out of content .
. the user's agent then has to either create or have available
the trees of fieldnames separate from the content
and must be able to serve thses names to voiceover,
or whatever reader is on the system .
. there are more options if the user can touchtype:
getting through a list, and hearing an r-word,
pressing r would stop it at the last r-word .
. otherwise, the arrow keys can still do what's needed .

journaling with efficient versioning

2.11: adde/journaling/efficient versioning:

. notice reverse diff can't be done by journaling,
needs exact replace commands:
eg, suppose block has x's
and I use command to replace all x's with y's,
but there are already y's .
then a reverse journal changing y's back to x's
is going to change too many y's
and therefore won't represent the previous version .
. reversing must keep track of either whole block versions
or use address of changes
-- in some cases the instruction for reverse
would be heavier than just keeping both versions .

sup' and subfile editor

2.5: adde/{sup, sub}file editor:

{sup, sub}file editor:
superfiles are a collection of files selected by user,
search , etc
and then in addition to a list view,
there's an edit view that lets
see contents of all filesat once
. file inclusion is determined by label:
if you delete a label,
it asks if you meant to kill a file a file
and append it's content to the file above .
. if choosing to exclude label from deletion
that allows your {cut, delete} to affect multiple files at once
without affecting fs structure .
. adde's folder view allows opening all files of any subfolder .

menu backspacing

2.2: adde/gui/menu backspacing:

while in menu mode
. instead of having enter after char
one line is confiriming what you just picked ,
and the new menu appears if filling a record .
then backspace does reverse
pulling line and going back to prev' menu .

for see to be effective
be sure to know your apoptosis rules
diet should not urinate
thyroid and burnrate increasers
will make poison felt by more .
cancers are most active during acidics
(body feels burning with acid from being out of shape may be a good time? )
need to know more about how apoptosis works
and how antiapop's work .

dvcs with gui on mac for securing data

2.28: summary:
. notes of my journey deciding on Mercurial .

2.1: news.addn/dev/scm/internals of git:
. the popular $9 [Git internals] book from Peepcode.
man page everyone should read:

2.1: proj.addn/dev/scm:

. how is svn on {tortoise, mac} knowing where to check;
is there something integrated on mac?
. how do you limit growth of the time mach aspect?
be careful with your updates (don't commit a bunch
you'll only be deleting later);
export and reimport .
. make sure backup is obvious when transfering things to git .
. consider project size;
is svn smarter replacement of mac timemach?

scripts instead of gui

SmartSVN 79.00
xMerge add-on (Merging renamed/moved files) 399.00 USD
. after that, I'm wondering if that lack of xmerge
was the reason git's inventor calls svn braindead .

. hg might have better doc's?
and it's already installed on mac x.6 .
The hg executable is now placed in /usr/local/bin for all versions of the installer.
For OS X 10.5 & 10.6
The package uses the default Python installation that comes installed.

darcs might fit my use case well


Is there a way for Bazaar to be able to automatically detect changes (adds, removes, renames, etc.) made to part of the working directory and automatically apply them?
It looks like the automv plug-in will automatically detect renames and moves. This, along with bzr add * should do the trick.


bzr copy doesn't work as expected

there is a rebase plugin available for Bazaar ( bazaar-vcs.org/Rebase)
and a queues one (launchpad.net/bzr-loom).

Bazaar does line-ending conversion already, since 1.14:
through a plugin (bzr-eol)..


Bound branches are a way to make sure that both a local branch
and a remote branch have the same revisions.
This is particularly useful if one likes to work on two machines .
online plugins guide

pos.addn/dev/scm/for mac and pc:
. maybe I can use svn on pc side,
then use timemach on mac side?
Using Git With OS X: 6 Tools to Get You Up and Running

2.2: proj.addn/dev/scm/installs not going as expected:
. explore downloads meant for installing,
didn't I miss something about scm?
I looked at several things yesterday,
and I don't have anything in a context menu .


bzr-explorer for mac looks great
but the installers are only for pc:
download icon bzr-explorer-setup-0.11.2.exe (md5, sig)
Windows universal installer 198
download icon bzr-explorer-0.11.2.tar.gz (md5, sig)
Source code
. the visual tour of that .
Standalone Installer page says it includes several gui's:
This is typically the best choice for most users and includes:
* the core Bazaar distribution
GUI clients - Bazaar Explorer, QBzr and optionally TortoiseBzr
numerous bundled plugins including BzrTools, bzr-svn, bzr-upload and bzr-xmloutput
* bundled Python (currently 2.5) interpreter with most (but not all) libraries.

for mac, there is a set of tools, no gui :



mac has tools update here
and great doc's;
it also has a pkg that includes hg with tortoise for pc .
. it's the same one I got here: http://tortoisehg.bitbucket.org

textmate has scm support,
group collects why textmate is great;
note there is a clone for pc too:


[@] proj.addn/backup/log under hg control

2.8: bk.addn/dev/scm/patches:

. patches are files that show how 2 versions of a file differ .
. they're an alternative to journaling files
describing all changes in terms of
whole-line deletions and insertions .
. each contiguous pair of deletions and insertions
is refered to as one hunk of the patch .

. unix makes a patch with diff(txt,txt).patch,
and applies a patch with patch(patch).txt
. patch() doesn't represent folder systems exactly:
file creation doesn't show up if no lines were added;
and, file deletions don't show if the file was empty .

. patches are still being used as an alt' to
scm or version control systems
since the effect of each patch is the same as
one changeset -- the changes produced from
moving from one version to a child version .
. patches are typically used for customizing a codebase;
esp'ly when you aren't influential with that project
and can't get them to add your patches
as conditional compilation stmt's .
. in some large projects like the Linux kernel,
replacing patches with conditionals
would make the code unreadably complicated .

. combining scm with patching,
changes can be saved as a patch:
at any point where you could hg`commit,
you could instead diff() .

2.8: tips from trinitycore.org:

A tip about merging tool.
kdiff3.args=-L1 base --L2 local --L3 other $base $local $other -o $output
kdiff3.args=-L1 base --L2 local --L3 other $base $local $other -o $output --auto
sometimes you have hundreds of files to merge
but kdiff3 can solve conflicts automatically.
If you do not add "--auto"
you have to manually close the spammed kdiff3 windows.

hg serve
. the webserver option allows us to create
a great looking repo page for your local repo
on any port of your choosing.


. for getting eoln's done right,
-- where files checked out to a pc have pc eoln's --
my plan is to use yet another clone
on the main hard.drive,
after affecting some setting,
is this right?:
[configure repo'].window/diff/[Patch EOL]
-- default is no normalization,
so it's set to: platform?
( pc: crlf
, mac: lf
) .
you can tell when you've done this right
because agent-ransack or notepad will act right
and not ball-up the whole file on one line .
. instead of doing another clone,
I'll just add a working dir' to backup's clone
with backup`menu/tortoiseHg/update .

2.8: correction didn't take:

. after changing the hgrc file,
I cloned that to my xp's shared.folder;
but this did not work either .
. maybe I should clone without update,
then modify the new clone's hgrc,
then update .
. in any case I should do more booking:
file:///C:/Program Files/TortoiseHg/docs/hgrc.5.html

Filters for transforming files on checkout/checkin.
The most common usage is for
LF <-> CRLF translation on Windows.
For this, use the "smart" converters
which check for binary files:

hgext.win32text =
** = cleverencode:
** = cleverdecode:

Win32TextExtension short-comings:

biggest problem:
* The settings are not part of the repository
so all users must configure it for each clone.
. they would rather replace universal eoln's
with metadata which tells all cloners
that a given file or file`type
is supposed to use a particular eoln;
meaning that there must unversally be
tools that support a file's current eoln type .
Mark Hammond Dec 1, 2009:
. server-side hooks that force the line endings?
(ie: project/.hg/hgrc#[hooks]
pretxncommit.crlf = python:hgext.win32text.forbidcrlf
. this would only apply at *push* time,
not commit time. [ie, this may help the central repo,
but the lower-level repo's will have
already had their repo' histories destroyed .]
Given the distributed nature of hg
it seems that by the time a server-side hook kicks in,
the damage has already been done .

tips from trinitycore.org:
some bugs related to eol:
1. your patch modifies the whole file instead of only a few lines
2. you cannot apply patches (hunk failed)
3. your whole file is modified even if you did not change it
4. you cannot open .sln files using vc++

how to solve the problem:
1: apply hgext.win32text to [user's] global config file
[... and other steps if you're applying patches]
2: re-clone your local repo (must re-clone)
3: dos2unix and unix2dos are also handy:
. a patch is usually made with Unix`eoln's
but the patch needs dos`eoln's (with unix2dos)
in order to be applied to a source
that is cloned under the win32text extension .

another mod having a similar effect:
I was having a problem with
differences in whitespace
showing up into my patch files.
This added to my .hgrc helped that:
-- also, I no longer need to run this after updates:
dos2unix `find ./ -name '*.cpp' -o -name '*.h'`

2.9: here is the eoln ext's man'l!

. the reason for the change not sticking
was that the encode or decode filter settings
should not be changed while you have files checked out
- use hg update null
to remove any working files first.
[from the gui, tortoiseHg,
it might be easier to delete and reclone]

the filters come in two variants:
A "dumb" filter which modifies
anything looking like line endings
in all files it is applied to,
and a "clever" filter which only works on
files NOT containing zero bytes.
[what does "(not work) mean ?]
The simple heuristics used by the "clever" filter
will fail in some cases,
but it often works so well
that it can just be applied to all files.

a warning about the eoln extension:

. win32text is user-specific, not repo-specific.
This was not what we wanted;
svn's svn:eol setting is really handy
and has turned out to be great to have around.
. the hgeol extension currently under development
tries to mimic svn's eol function .
. the plan is to have the .hgeol file
under version control
It would specify how files should be checked out
(e.g. native for the OS, \n, \r\n, or binary)
and make sure that no checkins
are going to lead to bad line endings.
[... but for now]
seems the encoder doesn't work
during conversion as the 'crlf'
commit hook fails.
Is it currently possible to correct the EOL
style of files during repository conversion?

. I used the win32 eoln extension
without the patch option, restarted,

2.10: sci.addn/dev/scm/hg`mov:
. after adding and moving,
I did commit/add (all);
then I tried the commit/mov.button,
and got this msg:
no movables; only clean files files can be moved .


. TortoiseMerge is the merge tool that comes with TortoiseSVN;
here is a note on using it from TortoiseHG:
. there were some conflicts from commenters,
and some known caveats weren't mentioned,
so I need to check this against the doc's, and some testing .

. add the following to your mercurial.ini file:
. My TortoiseSvn installation has a space character in the path,
so I need to add quotes around the file locaters:
To use this, I have to set Global setting or repository settings
to use myTortoiseMerge as
“Visual diff command” and “3-way Merge Tool”.

merge = filemerge

hgext.extdiff =

cmd.vdiff = "C:\Program Files\TortoiseSVN\bin\TortoiseMerge.exe"
myTortoiseMerge = "C:\Program Files\TortoiseSVN\bin\TortoiseMerge.exe"

filemerge.executable = "C:\Program Files\TortoiseSVN\bin\TortoiseMerge.exe"
filemerge.args = /base:$base /theirs:$other /mine:$local /merged:$output

vdiff = myTortoiseMerge

2.28: mis.addn/dev/scm/xpw.tortoisehg is getting complicated:

major pim change:
. log current year is part of pim.folder
. past log years are in log.folder .

trouble committing (2008 tucs)`L/2008/06 jun/System Scan - PLEASE WAIT - Scan in progress.html!
transaction abort!
rollback completed

[Errno 13] E:\pim\(2008 tucs)`L/2008/06 jun/System Scan - PLEASE WAIT - Scan in progress.html: Access is denied
[command interrupted]

. perhaps the reason for the access denial
is there is a file with nearly the same long name?
rename the other one .

(2008 tucs)`L/2008/01 jan/00.txt~: The system cannot find the path specified

. that error was a mystery as it wasn't reproducable .

software engineering officially defined

2.16: web.adds/sw.eng/official definitions:

. ABET (Accreditation Board for Engineering and Technology)
is the recognized U.S. accreditor of college and university programs
in applied science, computing, engineering, and technology.
. it is owned an operated by several pro' soc's;
most are amer'eng'ing, but some are internat':
INCOSE (internat' council on sys' eng')
started out as an amer'group:
National Council on Systems Engineering (NCOSE)
. The purpose of a Systems Engineering society
was to "(address the apparent shortage of
qualified engineers who could think in terms of
a total system — rather than just a specific discipline.)
. sys'eng'ing includes Software engineering

"(the application of computer sciences, project management,
and other techniques to create computer software.
While it started out as a mathematical discipline,
software engineering now has the characteristics of
an engineering discipline.)

Additionally, many online advanced degrees in SE have appeared
such as the MS in SE at California State University, Fullerton.

Software Engineering 2004 (SE2004) Curriculum std

"( The Software Engineering 2004 (SE2004)
is a document that provides recommendations for
undergraduate education in software engineering.
Its development was sponsored by the acm
and the IEEE Computer Society.

Important components of SE2004 include:

the SE Education Knowledge,
a list of topics that all graduates should know,
as well as a set of guidelines for implementing curricula
and a set of proposed courses.

SWEBOK (the SE BOdy of Knowledge)

. SWEBOK, which has become an ISO standard
describes the body of knowledge covered by a software engineer
The SWEBOK also defines disciplines related to software engineering
* Computer engineering
* Computer science
* Management
* Mathematics
* Quality management
* Software ergonomics (Cognitive ergonomics)
* Systems engineering
The difference from (SE2004, CCSE) is that
whereas SWEBOK defines
the software engineering knowledge that practitioners should have
after four years of practice,
the SE2004 (pdf) defines the knowledge that
an undergraduate SE grad should have
(including knowledge of mathematics, general engineering principles,
and other related areas).

swebok def of sw.eng:

The IEEE Computer Society defines SE as:
The application of a systematic, disciplined, quantifiable approach
to the development, operation, and maintenance of software;
that is, the application of engineering to software.
"The legitimization of professional authority
involves three distinctive claims:
that the knowledge and competence of the professional
have been validated by a community of his or her peers;
that this consensually validated knowledge rests on
rational, scientific grounds;
and third,
that the professional's judgment and advice
are oriented toward a set of substantive values,
such as [linguistically programmed automation]
These aspects of legitimacy correspond to the kinds of attributes
— collegial, cognitive, and moral —
usually embodied in the term "profession."


Gary Ford and Norman Gibbs studied several recognized professions,
including medicine, law, engineering, and accounting.
They concluded that an engineering profession is characterized by
several components:
. an educational curriculum accreditation
. Registration of fitness to practice
via voluntary certification or mandatory licensing
. continuing education
things outside the swebok scope:
Communal support via a society [or union]
codes of ethics

Without such a consensus on a Body of Knowledge
no licensing examination can be validated,
no curriculum can prepare an individual for an examination,
and no criteria can be formulated for accrediting a curriculum.

1. To promote a consistent view of software engineering worldwide
2. define how it differs from other disciplines
such as computer science, project management,
computer engineering, and mathematics
3. To characterize the contents of the discipline
4. To provide a topical access to it
5. To provide a foundation for curriculum development
and for individual certification and licensing material

google'code fully supporting mercurial repositories

2.7: proj.addn/net.g'code/getting started with hg repository:


. before figuring out that I could use hg instead of svn,
I did try the [Reset This Repository] for the addx project:
Did you just start this project
and do you want to 'svnsync' content
from an existing repository into this project? yes:
Resetting the repository will delete
everything in the repository and its history.
This includes project wiki files.
Reset this project's Subversion repository
from revision 1 to revision 0.
A project owner can then use the svnsync tool to upload existing code history.
. Mercurial an option for all yet? yes:
Convert your project from Subversion to Mercurial
1. Go to project/Administer tab/Source tab
[eg, mine is https://code.google.com/p/addx/adminSource]
2. Change the repository type to Mercurial
* Root directory: /
* Trunk directory: /trunk
--[ change this to empty because my current repo
is empty so /trunk doesn't exist .]
. all projects were converted to hg repo's:
for add* in {addx, adda, adde, addm}:
default: https://add*.googlecode.com/hg/
wiki: https://wiki.add*.googlecode.com/hg/

. now the source page confirms I'm with hg:
get a local copy of the add* repository with this command:
hg clone https://add*.googlecode.com/hg/ add*

easy downloads
. use the Downloads tab to upload compressed files.
(eg, mine is https://code.google.com/p/addx/downloads/entry)
. choose the file names carefully
as you cannot change it later. [except by deletion]
[. the downloads could be
the easiest way for everything:
. doing doc's by wiki is ok on a netbook,
but if you have a prefered html editor,
the best way by far to distribute doc's
is to simply zip the folder structure into
one downloadable book .
. if working alone, then this is the way to
keep your source code in any repo system you want
(eg, you could migrate from hg to git);
however, the problem with monolithic downloads
is not being able to update them incrementally:
it gets expensive on bandwidth
to re-upload the entire thing for each revision .]
. predefined download labels useage
was a mystery to me for now ...
[2.28: perhaps becomes obvious during an upload .]

todo: [2.28: done] uploading to g'code with a gui
. there is a how-to for using TortoiseSVN,
it needs to be adapted for use with Tortoisehg ....
[2.28: done with the help of tortoiseHg tutorial]
. find your google'code ID in your project's home page,
eg, for project addx, home is:
at the bottom it tells the owner's name:
-- mine's dr.addn, as seen here:
. to find your assigned g'code password
see g'code's "Settings" tab .
. In Windows explorer, [on the mac? try vmware]
right click in your repo' directory's context menu,
and choose TortoiseHg/Repository Settings/Sync.tab/add.button
and then the dialog is obvious about filling in
your g'code hg repo contact details:
( URL: https://addx.googlecode.com/hg/ (for the addx project)
, user: dr.addn
, password: (see http://code.google.com/hosting/settings)
. now to do the uploading to your hg repo' at g'code,
right click n your local repo' directory's context menu,
to get TortoiseHg/Synchronize .
. the dialog will have a line that says:
[repo:][bundle:][(repo' pull-down menu)] post pull:[(pull-down menu)]

. when you pull down the [(repo' pull-down menu)]
you will see the contact details you filled in during
context`menu/TortoiseHg/Repository Settings/Sync.tab/add.button
mine looks like this:
(the *** represents the password you entered) .
. select it to make it show in the menu .
. now at the top of the dialog is the push.button;
ie, a button that launches the Push command;
pushing your local repo's state into your g'code repo .

tortoiseSVN is still there
. here's a google-authored page for
using g'code with tortoise svn instead of hg .
. it recommends an svn client for mac too .
[2.28: I'm using tortoiseHg on the mac via vmware
which allows windows to run in a mac window .]