R128, R129 – pushing and popping

I now have kind of a plan, more than the one that always was in my head. Current efforts are directed towards implementing just any program file reading – with scanning and parsing – that makes it possible to generate all constellations. But the pushing and popping of program states must be implemented first.

• R128 (4 dec, 2011) starts with this pushing and popping, although it is not tested yet.
• R129 (4 dec, 2011) The code for this pushing and popping called in the main program. Works for the hard-coded star map generation in the main.

Constellation Monoceros, the Unicorn

R126, R127 – finally woke up again

I finally woke up again, after some tough months of studies. The pedagogical quality of Microsoft teaching material have some deficiencies. Still studying MCTS 70-640 and MCTS 70-680, but the material needs lots of analysis to be comprehensible on a deeper level. It's easy to imagine that Microsoft doesn't really want people to know how their Active Directory is designed, although I cannot find anything wrong (except some immature rigidities) in the design. They have made a pretty good job about it, however much I'm negative against attaining religious software stances. The only feature that looks weird and unlikely to succeed in MCTS 70-640 is AD RMS.

• R126 (Dec 2, 2011): The latest sternons change is more of this "carving plaster" stuff, where dynamically setup objects are to be created. The current change is just a minuscule change setting up the classes by using my 4b wide uchar strings in the function init_star_class.
• R127 (Dec 3, 2011): More of the same.

ITIL Foundation

I passed the ITIL Foundation test. That means I am a stone in the Foundation, so that any ITIL boss can put me in an ITIL box hole. The topic is very interesting indeed, although the typical ITIL (potentially destructive) box-thinking is at most 25% of the truth about group collaboration and organization – the missing truths are about psychology, sociology and the mystical part.

As a bad side of this test passing, two of my nearest classmates didn't pass. They were sad and irritated. I tried to encourage them to allocate one day in a week for ITIL reading, so that they pass the test at the next opportunity.

Lithium deficit primordial star

(Credit: ESO/Digitized Sky Survey 2)
SDSS J102915+172927
α(J2000): 10ʰ29ᵐ15.15ˢ
δ(J2000): +17°29'28"
Const: Leo
m: 16.92

SDSS J102915+172927 is one of the extremely metal poor stars in this universe, meaning it was formed "shortly" after Big Bang, but it contains only one fiftieth of the amount of lithium expected to be formed in the Big Bang. Stars have a tendency to destroy the fragile lithium nuclei, so the problem is not serious, but if the lack of lithium cannot be explained in that way, the Big Bang and current models of physics are in trouble.

The astronomers have a strong suspicion that there are many more of these extremely metal poor stars, and are planning to study them with the VLT.

ESO news release here.

Nature article here.

Preliminary devenv choice

The infinite blessings of C# and Java aside, I've for a while considered using mainly (mostly) C++/wxWidgets. The reasons are that

1. the combination presumably taxes the computer running the programs much less, and
2. that I, as a developer, have a freer choice of perusing whatever API I need for the application,
3. and at I at the same time am in full control of the memory allocation (garbage collection is not a good idea).

Garbage collection has been praised for years as a way to improve the program, make it easier to develop it, and to make a better, more glorious and generally überphantastique program that gleams like gold in the distance (the irrational emotional aspect of programming religions). In immediate contact with these überphantastique programs, the "gold" is revealed to be a cracked surface of shallow paint: Android the überphantastique operating system for übertelephones deLuxe professional, very much unprofessionally freezes (!) for minutes, while the somewhat not so boasted JavaScript engine in Mozilla by function eats up memory till it is full: it is some kind of least effort, most sloppiness garbage collection scheme. A worse case is google-viral-chrome that goddamn boasts about having an ultraüberführer fast stop-the-world garbage collector. This is criminally insane, like boasting about cleaning the city streets by blasting away all parked cars, and sweeping away the scrap in minutes!

Java is pretty good for producing executives that are portable. C# is not good for that, since it is quasi-strictly Windows-only. (Allegedly it's better than Java, but that matters naught if it's not portable). The problem with Java is it's virtual machine bloat: you don't need all of it, usually, and it eats your resources. Garbage collection is a bad thing, but one can choose garbage collector by using some runtime call; one might also write code to avoid it. Still it's overkill and not quite as portable as generally believed.

One disadvantage with my choice of C++/wxWidgets is that C++ have access only to the Boehm Conservative Collector, and I don't know its behavior. The second point is that wxWidgets provides 16 bits Unicode when I use 32 bits Unicode. Maybe it's rehackable, but I'm not sure.

Undesirable "feature" in string literals conversion

My own string literals conversion program contains an undesirable "feature", namely it converts also strings in comments. It would be better to keep the comments as they are, when a file is converted from .uc to .c, so that the .c keeps being more readable.

R123–R125 – Still not dead in Reinfeldt Hell

Yet a few other microscopic releases – the socioeconomic conditions as an unemployed in Reinfeldt the Cheater's Swedish Hell are complicated and requires more than 130% of full working time to fulfill, while the bureaucracy and income delays worsens. Since nobody's going to employ me, for irrational reasons, I have to beat up this quasi-dead donkey: preparing a book give me experience and some hope of getting away from these horrible Reinfeldtian conditions by my own writing and programming.

The still not dead donkey:

• R123 (Sep 2, 2011): Prep for dynamic class creation by func call – i.e. I'm working in minimalist steps towards a call in my mkmap language that dynamically creates an object type, f.ex.:

     class star { Bayer, HIP, HD, α, δ, π, RV, Mᵥ, SP };
  

  which defines a star to have a Bayer designation, a HIP Hipparcos number, a HD Henry draper number, an α/δ position (right ascension and declination), a parallax π, a radial velocity RV, a visual magnitude Mᵥ and a spectrum SP. The given attributes of the class are hardcoded, Bayer is presumed to be a string, HIP, HD integers, α and δ reals (floats) and so on.
• R124 (Sep 2, 2011): Fix bad object linking of allstrings.o – in fact the new object allstrings.o was introduced.
• R125 (Sep 3, 2011): Further object setup – making some default settings in object setup: first a type, then a pointer to previously loaded object.

CompTIA Network+

CompTIA Network+ completed in 19 august. First try as usual. I read and studied like a maniac, but the points achieved were simply ordinary.

R118 — R122: own string literals

Slow slow progress! I'm in the middle of a sequence of marketing improvement courses (CompTIA A+, Network+, ITIL, Windows 7, and Windows Server 2003/2008), so the progress at sternons mkmap is proceeding very slowly. I like learning courses, so there's no real trouble, but I also would like to develop my private astronomy book plans requiring star maps, and similar. Maybe also I'll be lucky enough to get a job that contains a little C programming beside the PC-administration or networking jobs I'm preparing for.

The releases r118 to r120 slowly continued the novel dynamical object system produced by "carving plaster" – let's call it the plaster object system – but then I realized how tedious it is lacking string literals for pure 32 bit int wide strings.

Lacking those, I hacked a converter (neither a parser nor scanner – more like an oversimplistic preprocessor) that scans a file, collects strings with the syntax u"example string" perusing an initial nonstandard u" as a string marker for my own string literals. Now the function ustring_to_attrib in file pointobj.uc is converted as follows

source pointobj.uc	target pointobj.c
int ustring_to_attrib(uchar *ustr) {   if (0 == ucscmp(ustr, u"RA"))     return POA_RA;   if (0 == ucscmp(ustr, u"R.A."))     return POA_RA;   if (0 == ucscmp(ustr, u"α"))     return POA_RA;   return POA_none; }	int ustring_to_attrib(uchar *ustr) {   if (0 == ucscmp(ustr, _UC_RA))     return POA_RA;   if (0 == ucscmp(ustr, _UC_R_2E_A_2E_))     return POA_RA;   if (0 == ucscmp(ustr, _UC__3B1_))     return POA_RA;   return POA_none; }

All such 32 bits wide string constants are then collected into the file allstrings.h, containing (among others):

static uchar _UC_R_2E_A_2E_[] = {'R','.','A','.',0}; /* R.A. */
static uchar _UC_RA[] = {'R','A',0}; /* RA */
static uchar _UC__3B1_[] = {0x3B1,0}; /* α */

The releases in chronorder:

• R118 (May 25, 2011): "More plaster carving towards dynamical classes" experimental refactorings directed from static defines to dynamic allocation
• R119 (Jun 13, 2011): "In the middle of refactoring" more mature refactorings in the same direction
• R120 (Jun 13, 2011): "More object class refactorings" more refactorings – removing a conceptual flaw: the object type identifier must (!) be stored at the same position in all objects, minor other code fixes
• R121 (Jul 22, 2011): "Further walking around Windows wide C-string limitations" novel invention – half-way wide string literal converter implemented: demo conversion seems OK
• R122 (Aug 1, 2011): "String literal converter - ucliterals" the above wide string literal converter implemented and perused in code generation

R121

See R118 — R122: own string literals.

SVG in XHTML??

Since Blogger peruses XHTML 1.0, the following shall display as graphics if your web browser supports XHTML and SVG natively. ERROR, ERROR! However I layout the XHTML headings, Blogger adds <meta> tags into my heading that are violating XML. The reason that the following displays a figure in gecko based browsers is that it nicely interpret the code as HTML5 containing embedded SVG:

It should look like this:

Preliminary tests indicate that it works well in Mozilla Firefox (6.0) but not in browsers using Webkit, f.ex. Epiphany and uzbl.

Mozilla Firefox 6.0β	Gecko/20100101	YES!
uzbl	Webkit	yes?
IE 10	Trident	YES! actually and surprisingly!
epiphany 2.30.6	Webkit	yes, but only if served as file.xhtml
konqueror 4.4.5	KHTML	no

It seems my troubles are due to the immaturity of most browsers, and their general unwillingness to adapt to web standards. It also seems that Blogger serves a lot of <link> tags that are invalid according to XML, making it impossible to adapt this blog for inclusion of SVG insets. It's just sheer luck that it works with Firefox.

The points of this experiment are

1. that Blogger shrinks the pixmap images that are downloaded under the assumptions that they're photos, not instruction figures (see dynamic classes for how instruction figures becomes), embedded SVG may remedy this
2. embedded SVG/MathML is the best part of the confused future HTML5 standard, and the only real advantage of HTML5, however deficient in comparison to XML embedding.

CompTIA A+

This week I managed to take a CompTIA A+ exam. It was tough. During the course preceeding it I got the following negative reflections about it:

• the system with English learning books and English examinations in Sweden counteracts the Swedish immigrants integration into the Swedish society — Swedish examinations should be in Swedish,
• the so called computer terminology (jargon) is the worst linguistic mess imaginable, where brands are confused with technology solutions, and there's no distinctions between adapters, adapted wires/connections, or technology, everything termed with three letter abbreviations,
• one cannot explain problems to the customers using the "established" computer jargon — there's a very distinct need to educate computer professionals in presentation techniques for customers and end users.

The course itself then? Well, pretty different from university courses. I learnt a lot about the basics that is important for a computer professional. The coverage was PC and basic Windows from a problem solving perspective, but not so much about the fundamental workings of the computer and the operating system. There was nothing about Linux – that's another cram course.

MinGW

MinGW is a free gcc for Windows, not using the Cygwin.dll Posix compatibility layer. For the sternons tools, MinGW is to be preferred (or a purely Windows based compiler), since it is to mainly be designed to not contain any Unix or Posix related calls.

I tested to install MinGW on a VMware XP copy of mine, and compile sternons mkmap. I generated SVG:s and the result was successful. Thus: mkmap compilable under a Unix gcc, Cygwin and MinGW.

R119 and R120

See R118 — R122: own string literals.

R118

See R118 — R122: own string literals.

Rursus, etc.

Epsilon Coronae Borealis:

154

Quæ hanc rurſus comitatur

13.32 ♏

46. 9ſb

4

1

corb

106

Modern latin text:

Quae hanc rursus comitatur

I also registered on vulkan.se in order to prepare for writing an astronomy book in Swedish... L8R!

Dynamic classes

The dynamic classes are implemented as per above:

• class table: the class descriptor is just an attribute indexed (type, RA, RA_Δ, etc.) array with indexes pointing out to the relative offset of the attribute in question.
• all the attributes within the class table, their names and numbers, must either be hard-coded or loaded to be known at the time when the class arrays are allocated, since each class array must be indexed by all known attributes,
• object layout: objects are allocated to contain exactly what the class array allows, and just nothing more ¹).

¹)	with the natural exception for pointers to memchunks representing objects in a quite different way

R113 — R117: carving plaster

The latest functionality adding revision was R112 adding labels to make navigable constellations. The following revisions (currently R113 — R117) have the general intention to refactor the celestial objects in order to allow dynamical class creation to be perused in the mkmap language; the redevelopment was originally slow, actually I didn't know what class model to use.

For celestial objects, it is necessary to be able to define the classes in runtime. Therefore I'll prepare a class system with inheritance, where the class tables list what attributes are available, what types those attributes have, and in what bytes they are stored within an object of that class.

For map projections, it will suffice with hard coded projections defined in the mkmap code. I'll therefore peruse structs containing a pointer to the virtual table containing pointers to the function performing the projection on a position ⟨α, δ⟩ given certain projection parameters.

I'll document the implementations in better detail elsewhere.

The releases in chronorder:

• R113 (Mar 26, 2011): "REFACTORINGS: ..." is a self-glorifying name for: "I didn't do very much, except shuffle around the code arbitrarily"
• R114 (Apr 2, 2011): same thing also this revision
• R115 (Apr 14, 2011): added a Knobel list of star descriptors (≈ names) never used in West, but listed in Al Achsasi's calendar from 1534¹) as stars along the ecliptic, not very important
• R116 (May 7, 2011): "intermediary code chaos revision", the star struct partially replaced by plain allocated memory, working on Linux only.
• R117 (May 16, 2011): "Carving plaster" the star struct now fully replaced by plain allocated memory, working on Linux and Windows; the object types (classes) won't be readable as structs in the code.

"Carving plaster" means that I'm working outside the PL abstractions (f.ex. structs) to be compared with the furniture of the room, and working with the computer raw material "the walls": bits-n-bytes. Now the task at hand is to be directed towards documenting and coding so that I (and code readers) get a grip on how it is implemented.

¹)

Western star names are generally some kind of pronunciations of Arabic star names, f.ex. Rigel (α Orionis) is from Rijl Arabic for "foot", but those names were generally transcribed in the wake of the First Western Renaissance of circa 1100–1347, presumably from the newly conquered library of Toledo in the Reconquista where Spanish Christian powers conquered the islamic Al-Andalus step by step. Many transcriptions were severely obfuscated by misread Arabic letters.

R116

See R113 — R117: carving plaster.

R115

See R113 — R117: carving plaster.

R114

See R113 — R117: carving plaster.

R113

See R113 — R117: carving plaster.

R112: Labels

Star labels added in R112: this is intended to be the last cosmetic fix before a general "refactoring" phase preparing for:

1. synergic mergers of similar structures according to C object orientation techniques – perusing similarities in struct declarations using a type tag and perhaps a virtual table implementation providing real dynamic method dispatch, such as generally invisible in C++
2. thereafter program loading and map setup.

I would have liked to sprinkle my star maps to Wikipedia sites (and Citizendium where there are no images at all), but it won't happen before program loading becomes beta and so mkmap becomes alpha.

R111: Delporte 1930 area

Constellation Orion again: darker background for the Delporte 1930 constellation area. This was accomplished in R111 of Mar 5, 2011.

A note on Streaming theory – r87: that theory is dead and buried — mkmap cannot use streams because loaded data is reused again and again, and some loaded data peruses earlier loaded data. No streams, but instead database like queries.

R107 — R110: Constellations and asterisms

The maps that were exhibited in posting "Example maps" were generated from R110 adding Constellation bounds. Revisions from R106:

• R107 (Feb 8, 2011): ripout of star struct into star.[ch],
• R108 (Feb 17, 2011): microscopic struct attribute and function renames,
• R109 (Feb 26, 2011): adding asterism line drawing,
• R110 (Mar 3, 2011): adding code for loading and drawing constellations' bounds.

The project is as alive as possible, given the current life conditions. I'm doing "practice work" in my church¹), full time, and some voluntary works at that church in the evenings, whenever I'm not applying for jobs that none is going to give me. This blog and the sternons project is designed to be a "job application merit", but it doesn't matter, because I'm 50 years old and nobody in Sweden is going to employ me anyways ²). My real purpose with this blog and the project are the star maps, just the star maps ... and to whatever use one may put star maps ...

¹)	Willingly: it's my church, just not the nearest church.
²)	Capitalism sucks, truly: any system that refuses to employ a well educated healty computer engineer with full working capacity under a hot boom when there's a shortage of computer engineers, is a sociopathic system (I'm hereby mild and reconsiling).

Example maps

Monoceros, a constellation that formally is overlapping the galactic equator but still pretty devoid of bright stars like the neighboring Orion. Lot's of deep-sky objects, most prominently the Rosette Nebula near the "head", and the sparse but bright open cluster NGC 2244 that have blown up a cavity in this HII bright nebula, which is excited by the hot young stars of that open cluster. The constellation seems to have been formed from stellae informata by Petrus Plancius near the turn of the 16th to the 17th century.

Orion is the heavenly hunter that boasted that he could kill every possible animal on this planet. Gaia, Mother Nature, then became pretty upset, and sent the Scorpion to kill the blasphemer. Orion the constellation is in direction of a real star craddle of Milky Way. Young bright stars are numerous. M42 and M43, the Orion nebula is part of one of the most studied star formation areas of the heaven, containing protoplanetary disks and young protostars cocooned in dust and dark hydrogen gas and thence only visible in the IR range of electromagnetic radiation.

R109

See R107 — R110: Constellations and asterisms.

R108

See R107 — R110: Constellations and asterisms.

R107

See R107 — R110: Constellations and asterisms.

R102 — R106: Docs and DB

Log of changes since last report:

• R102 (Jan 30, 2011): minor restructurings inspired by the program loading experiments previous early winter,
• R103 (Jan 30, 2011): more of the same,
• R104 (Feb 5, 2011): added my hand copied version of Tabulae Rudolphinae on a whim, probably the only one in database format on the entire web,
• R105 (Feb 5, 2011): doc cleanup,
• R106 (Feb 6, 2011): major rehaul to prepare for a novel database model (ADBMS) and to allow the struct program_state to be pushed/poped as procedure enviroments, added data and code for constellation lines.

R104 and R105

See R102 — R106: Docs and DB.

R102 and R103

See R102 — R106: Docs and DB.

Ada and UTF-8 literals

To my delighted astonishment, I found the following code quite legal in Ada05:

pragma Wide_Character_Encoding(UTF8);
with Ada.Text_IO, Ada.Integer_Text_IO;
procedure Read_Write_Loop is
    use Ada.Text_IO, Ada.Integer_Text_IO;
    β : String(1..40);
    N : Integer;
begin
    Put("> ");
    loop
        Get_Line(β,N);
    exit when β(1..N) = "quit";
        Put("Command: '" & β(1..N) & "'");
        Put(" ("); Put(β'Length,2); Put_Line(")");
        Put("> ");
    end loop;
    Put_Line("Bye");
end;

"Ridiculous", the most programmers use to say, one can write beta in Java/C# (which by the way is the most phantastiqual language ever constructed by the most intelligent godlike gurus, yada yada yada ...). Very nice when encoding mathematical formulae in Ada.

The above code works in GNAT if the data is stored in a file read_write_loop.adb and compiled with

gnat make read_write_loop

Other perceived advantages of using Ada for numeric parts of the sternons project are:

1. Ada is available wherever gcc is
2. The Ada programmer have a detailed control over data precision f.ex. being able to declare long reals by type My_Float is digits 12;

R101: License change

R101: just a license change in the code from GNU LGPL to GNU GPL. The reason was easier code pilfering from other projects, of which the vast majority is GPL. Now, Microsoft's CEO Steve Ballmer also consider my code "a cancer", which is maybe honorable coming from him, and "viral" according to Craig Mundie, also Microsoft. Microsoft is nice, nice doggie, do not bark on bearded men with turban!

R100 (new year revision)

R100 occured after some time of vacation from the project. My dive into program parsing made me get some intuitive plan in my head for in what direction the project is going to be developed, but I believe the mkmap program syntax needs some heavy revision after I've rehacked the main non-program-parsing code in accord with my vague intuitions. That's the life with theory and praxis: back and forth, nilly-willy over the border of the true and the functioning.