Part of President Obama’s directive to remake government is to have agencies open up their databases to the public. The FCC about two weeks ago brought out a totally new FCC.gov – at least the facade is new.
Behind the scenes, the FCC is burdened with a “legacy”. They have made a large number of their databases available for download
http://www.fcc.gov/data/download-fcc-datasets
*** Geek alert *** [run away if you aren’t a geek]
Some interesting details are being mentioned. They are also making source code available for how to manipulate the CPDS (CDBS?) – the FCC’s database of licensing and other engineering information.
The FCC’s computerized data only goes back to 1979 – that’s about the time I was working on my second job after college. From their description, the FCC databases were maintained using FORTRAN – which just so happened to be the first computer language I learned – and used at a bank about the same time (never to be used again).
At some point they bought an automated code conversion tool that converted the FORTRAN code into C – whee! Automated conversion tools can work and save programming costs in the beginning, but tend to create completely unmaintainable coding on the output side.
This fits more into the “Because I can” than “Because someone wants it” – but I’ve now added the FCC application history to the Station pages along with links to access the other information at the FCC.gov web site. – for example for KDKA:
http://streamingradioguide.com/streaming-schedule.php?stationid=343
Haha… this is great stuff
S602:
fputs("\n$ Power [ kW ] --> \n",LUN(6));
switch(ftnread(5,IOSTAT,NULL,3,LISTIO,REAL4,power,0))
{
case 1: goto S600;
case 2: goto S602;
default: break;
}
if(*power <= 0.0F) { fputs("0 Power must be greater than 0.0\n",LUN(6)); goto S602; } /* */ S846: ftnwrit(6,FMT,F834,1,STRG,mikm,9,0); /* */ if(*n == 1) fputs("\n$ Enter RMS based upon 1 kW --> \n",LUN(6));
else fputs("\n$ Enter RMS at nominal power --> \n",LUN(6));
/*
*/
switch(ftnread(5,IOSTAT,NULL,3,LISTIO,REAL4,aplrms,0))
{
case 1: goto S602;
case 2: goto S846;
default: break;
}
/*
*/
*rad = 0.0F;
*az = 0.0F;
if(*aplrms > 0.0F || *(Tsignal->sig + 13) == 'G') goto S56;
/*
*/
S848:
fputs("$ For pattern size: Theo Radiation, Azimuth ? \n",LUN(6));
switch(ftnread(5,IOSTAT,NULL,3,FMT,F800,1,STRG,c18,18,0))
{
case 1: goto S846;
case 2: goto S848;
default: break;
}
if(ftncms(c18,18," ",1) != 0) goto S45;
/*
*/
if(*(Tsignal->sig + 13) != 'R') goto S56;
/*
*/
fputs(" Signal 14 changed to G\n",LUN(6));
*(Tsignal->sig + 13) = 'G';
goto S56;
/*
*/
S45:
ftnread(INTERNAL,c18,18,LISTIO,REAL4,rad,REAL4,az,0);
/*
*/
S56:
if(*n > 1) goto S20;
FORTRAN used line numbers for controlling execution (there are variations on FORTRAN depending on how far back you go)
IF (I) 100,200,300
Says to GOTO statement 100 if I<0, GOTO 200 if I=0 and GOTO 300 if I > 0
Early users of BASIC (before Visual Basic) will see some similarity…
In 2000, the FCC converted its software from running on VAX machins to whatever they use now. That’s about the time DEC was swallowed up by HP….
My erstwhile wanderings should be posted here. Sheesh.
While it may be improving, the cumbersome government procurement and standards processes ensure that by a time software is delivered, it is already obsolete (or never gets finished and is abandoned)
I’ve known about the goto statement in C since I first started learning it 15 or so years ago, but never committed that particular sin. What a horrid mess this stuff is, but I guess that’s to be expect when coming from a language where goto’s are heavily used AND a conversion program has been used to port the original. Glad I don’t have to maintain that sort of code!
Yes, that’s exactly what this snippet of code is…. In FORTRAN you had a thing called a FORMAT statement, identified by a line number that said how to accept input or print output… C being about the same era has similiar constructs, except it didn’t use line numbers. FORTRAN was generally entered into the computer using 80 character Hollerith cards, so statements that were longer than that were hard to deal with. FORTRAN also didn’t do things with strings very well – it was a programming langauge for mathematicians. It didn’t have the notion of null terminated strings – most input was done a line at a time (indicated by a carriage return), and fields separated by commas.
The FCC would have been drawn to FORTRAN because a large part of what they do is engineering work – keeping track of the contours of each radio station’s signal and calculating theoretical signal strengths.
The DEC VAX was one of the pioneers in interactive terminals (VT-100s). That code seems to be interactively allowing modification of the values in the data (probably the data was kept in an ascii flat file – and only one person at a time could be using the file)
I’m constantly amused by people (usually recent computer science graduates) who worship at the altar of *nix, not appreciating that they are admiring an operating system and language that are older than their parents – and think it’s the latest greatest thing! One of my little “old man” sayings is that when a person only has used one language or operating system, they have no doubt it is the best one there is!
I’m pretty confident that if I un-retired, it wouldn’t be hard at all to find a job doing COBOL IMS DB/DC, paying much more than the recent college compsci grad is making writing L337 perl scripts grepping the logs on his linux servers. Your value to an employer is inversely related to how many other people have that same skill. There is a lot of “legacy” out there. The world is overflowing with underemployed perl geeks who would never use a goto statement as a religious issue. (“What do you think about using GOTO statements” was my boss’s make or break interview question – if you answered that you would never use a GOTO statement, you got shown the door)
Your comments about CS grads bring back some memories. I’ve always seen CS as a field that required a certain amount of natural aptitude to thrive in, and I even considered majoring in CS years ago until I worked a while at a college helping computer lab users. I remember one instance where I had to help a student who had made it far enough into the program to be taking a class on x86 assembly, but couldn’t figure out how on earth to use the DOS based (and fairly standard in functionality, if I remember correctly) text editor. That was just one of a few experiences that planted the seeds of doubt on the field of study (at least at that school), and I never did pursue it, although I did manage to find work doing similar stuff for a while.
One thing led to another, and I didn’t start in college until just a few years ago, but the same problem seems to plague a fair deal of the students I’ve come across so far. The part that disappoints me most is that current students have so many more resources available to help them learn than I did back then. And we won’t even talk about how different it was for you to learn. All that talk about Hollerith cards, DEC VAX and Cobol says a lot. 🙂
I know that there’s probably tons of legacy FORTRAN in use today, but I was pretty surprised when I started back to school to find out that are some majors that require it and it’s recommended for others. I didn’t even realize it was still being taught.
[enter old geezer mode]
The only computer we had at my college was an IBM 1130. It was all the rage in the 1960s as a table sized relatively inexpensive computer. By the 1970s, it had mostly been relegated as an RJE workstation and lived on in some corners of the government.
It had 8 Kilowords of memory. (8k of 16 bit magnetic core memory). Up until the year that I found it, the only people using it were math majors doing things like calculating prime numbers and calculating pi out to 100 digits….
It also had RPG, COBOL, APL. I was an accounting / business major and they decided they needed to offer a programming class After the first day, I realized I understood it better than the math professor, and never looked back.
I have a pretty clear filter to divide the people into those that will get it and those who won’t. Our school system trains people to memorize and forget. You can’t memorize computer programming. Every tiny detail is completely under your control (or not). Luck has nothing to do with whether your program works.
A variant on the education system is the pretty girl who smiles and tries to get the geek to do her homework. Needless to say, that doesn’t work out very well in the real world, either. When they grow up, then end up going into Q/A to then tell the geeks the right way to do things.
Perhaps point out to non-Geeks that the above is C language – not Fortran. One of C’s precursors was ALGOL. A maligned language at it’s time as it wasn’t made here (it was European). C was Bell Labs if I remember correctly. Smooth and uncluttered by line numbers. There are (heaven forbid) similarities between C and PHP as well. FORTRAN IV (Modified) was good at math (and not much else).
Very geeky, to be sure. Thank you for the stroll down memory lane!
I wonder how many C programmers even know it has a goto statement…