The First Bahadur comics published in Indrajal was Lal Haveli ka Rahasya (Dec ’76; IJC No.267). It was priced at Rs 1. It was also published in Bengali and Kannada language.
The story begins when a dacoit, Vairab Singh, who has been terrorizing villages, is shot dead by the Chief of Police Vishal. The dacoit’s teenager son swears revenge on the policeman who caused the death of his father. However, Vishal helps him turn over a new leaf. The boy was Bahadur, and he grows up to enforce law and order in the little bustling town of Jaigarh.
https://unboxedwriters.com/bahadur-the-first-ever-indian-superhero/

The history of Hindi comic books can be traced back to 1964, when Indrajal Comics, an offshoot of Times Group, published the first ever Hindi comic book titled Vetal ki Mekhla (The Phantom’s Belt). After gaining popularity among young readers, several American comic books were adapted into Hindi. This eventually led to the development of several publishing houses promoting hindi comic books with diverse characters.
Critically informed writing about comics, an endeavour with a long but often marginal history in the scholarly world, has flourished over the past two decades as never before. The rise of comic book studies is connected to the increased status and awareness of comics as an expressive medium and as part of historical records.
Amar Chitra Katha: Shift towards ‘Indigenous’ Comic Books
A major break in the publication of Hindi comic books came in 1967 when India Book House started the Amar Chitra Katha series helmed by Anant Pai. Trained as a chemical engineer, Pai joined the publishing industry in the 1960s, and was employed by the publication division of the Times of India. It is said that once Pai watched a quiz contest on Doordarshan where children could answer questions on Greek mythology but did not know the name of Rama’s mother.[4] His nieces and nephews also showed him stories they had written that had characters with English names. Pai found this alienation from Indian cultural roots disturbing. He conducted an experiment in a Delhi school to establish that the comic format works well as a mode of communication for young minds. He then conceived the idea of an indigenous comic book for children that would have the stamp of approval from parents and teachers since they would provide information on Indian mythologies and histories. He pitched the concept to Times Group but without any success. However, India Book House, a publisher based in Bombay, lapped it up. The series was named Amar Chitra Katha (literally, immortal picture stories) or ACK as it is popularly known. Although the first 10 issues of ACK were Western stories like Pinocchio and Cinderella, from the 11th issue onwards, it came into its own and started to publish stories related to Indian mythology.

Bahadur, which literally means The Brave, is a highly popular Indian comics character, created by painter, journalist, author, playwright, cartoonist and screenwriter Aabid Surti in the year 1976. The comic series was published and distributed by Indrajal Comics. Bahadur was released in many Indian regional languages such as Hindi, Bengali and also in English. Other than being published as a stand alone series, Bahadur was also featured in several newspapers and magazines as comic strips, along with other comic book heroes.

Concept of Bahadur
During the period when Bahadur was conceived in 1976, crimes like robbery had increased to a great extent in the country. The series of Bahadur focused mainly on the robbers and dacoit clans. Bahadur was born to father Vairab Singh, who himself was a dacoit. Vairab Singh died in a combat with the local police. During his teenage years, Bahadur was adopted by Vishal, the Police inspector who killed his father.

Bahadur later established the Citizen”s Security Force, also known as Naagrik Suraksha Dal (NASUD). This group was set up with the objective of providing support to the Police Force for combating dacoit clans. Even though he bravely fought with various groups of dacoits and other criminals, Bahadur mainly concentrated on correcting and rehabilitating the dacoits. His main sidekick and assistant, Lakhan, was also a former dacoit who was later reformed by Bahadur himself. Lakhan eventually surrendered himself to the law and started to work with Bahadur in restricting crime.

In the Indian comics series, Bela is portrayed as the love interest of Bahadur. She is an expert in various combat forms and techniques of martial arts. Bela helps Bahadur in various missions and his fights against his rivals. There were some other significant characters that were featured in the series on a regular basis, such as Lakhan, Mukhiya and Sukhiya. Mukhiya was the head of village administration and the leader of the villagers and Sukhiya was a police officer. Bahadur also had a dog named Chammiya, but it was introduced much late in the series.

Development of Bahadur
The Bahadur series gradually evolved in terms of artwork, plot and quality. Originating from the concept of dacoits in the small town of Jaigarh, the series moved to themes like espionage. Moreover, the setting of the story also shifted from a small town to a modern city. As the artists changed with time, the look of Bahadur was also experimented with several times. His initial attire remained same till 1986. Then his kurta was changed to pink and his trademark long hair was shortened to sport a new and urban look. Later his kurta was also replaced by a T-shirt. The series of Bahadur came to an end in April 1990, when Indrajal Comics was cancelled by the Times of India.

During 2010, it was planned that the Bahadur series would be made available on a new website on Bahadur. Moreover, there are plans to reboot the Bahadur character in the near future.
https://www.indianetzone.com/bahadur

References:
https://www.indianetzone.com/bahadur
https://unboxedwriters.com/bahadur-the-first-ever-indian-superhero/

The post Write up on Bahadur- The First Ever Indian Superhero (Historical records) appeared first on DayDreamin’ Comics.

Summary
The Commodore 64 microcomputer consists of a 6510 microprocessor, ROM, R/W memory, and various I/O devices. These are interconnected by the address bus, the databus, and the control bus. Each of the65,536 memory 22 1 D The Commodore 64 Microcomputer System locations is identified by its address. Each memory location stores eight bits of information, called an eight-bit code, an eight-bit number, or a byte. Memory is used to store both data and machine-language programs. The microprocessor can read a code stored in memory, operate on it, or store (write) a code in memory under the direction of a machine-language program. A program is an ordered set of instructions stored sequentially in memory. Instructions consist of eight-bit codes that the microprocessor reads, interprets, and executes. In order to be understood by human beings, the instruc tions are described by a mnemonic and an English language description. The instruction set of the 6510 consists of 56 different instructions. Six registers inside the 6510 are involved in the execution of these instructions. These registers are the accumulator, X register, Y register, program counter, processor status register, and the stack pointer.

INSTRUCTION TYPES
There are 4 classes of instructions in the 6510. These are:

• Data movement
• Arithmetic
• Thsting
• Flow of control
  13 Data movement instructions are instructions that cause a value to be loaded from memory, stored into memory, or transferred from one register to another. There are a number of options as to how the address of the byte to be loaded will be determined. In the load accumulator instruction, LOA, there are eight different addressing modes that can be used to determine which byte to load. The different addressing modes are explained in the following section. Arithmetic instructions are used to modify data in some way. This class of instruction includes logical operations, such as the ANO and ORA instructions. There are instructions that allow a byte to be rotated as well as addition and subtraction commands. As with the data movement instructions, most of the available addressing modes can be used by the arithmetic instructions.
  7 testing instructions allow a nondestructive test of data in the microprocessor. For instance, when a CMP instruction is used to check a value in the ACCUMULATOR, the data in the ACCUMULATOR will not be changed in any way. The bits in the STATUS register will be changed in the same way as if the data to be compared was subtracted from the ACCUMULATOR.
  These instructions are generally used to modify the STATUS register prior to executing a branch instruction. Flow of control instructions are the branching and jump instructions. These are used to change the order in which different sections of code are executed. The branch instructions are all conditional branching instructions. That is, each instruction checks one of the bits in the status register and, depending on its value, will either branch to the instruction pointed to in the operand or execute the next instruction in line. Jump and jump to subroutine instructions also fall into the flow of control category. These are known as absolute commands because they do not check any conditions before performing a jump
  Sprites, Bitmaps and Vectors
  In the beginning there were essentially two different ways of making computer graphics. Sprites/Bitmaps and Vectors.
  Vector graphics represented images as a series of mathematical equations, allowing for smooth lines and curves. The most notable example of vector graphics during this time was Atari’s arcade game “Asteroids,” which featured wireframe graphics. The game was widely cloned and arrived on all the 8 bit home computer systems in one form or another during the early 80s.
  https://www.cadasio.com/post/8-bit-sprites-to-webgl-how-computer-graphics-have-changed-the-world
  The Commodore 64 has the ability to generate sprite graphics over a character background. When this data area is created and a sprite is moving over the background, that data will not be erased. This is because the sprites are located in a different area of memory that do not conflict with the screen data. This independence gives it a great advantage when creating games. Any data or graphics remains in its own independent space.
  A sprite is drawn as 24 x 21 (503 bits) or 63 bytes of memory. So a sprite can be 24 bits wide, and 21 bits high. This area is also known as an MOB (Moveable Object Block). Up to 8 sprites can be displayed, animated, and moved on the screen. However, using a technique known as sprite multiplexing, even more sprites can be occupied with raster line timing. Basic is too slow to move sprites effectively, so assembly language is the best bet when trying to create smooth movement.
  The bytes are separated into individual bits for each row (ranging from 0-7), with the 0 bit being on the right. The values for each section (in an 7 bit layer) is displayed as 128,64,32,16,8,4,2, and 1. The total sum of these values in 255 which would draw a complete line across the width of the sprite.
  Multicolor Sprites
  Sprites can be in one color or in multiple colors, when a special mode known as multicolor is activated using memory locations ($D025 – $D02E), which is listed as 53287-53294 in Basic decimal mode. These multicolors are displayed when the sprites are grouped in pairs. As a result this expands a pixel to twice the width of a high resolution pixel. When lining up these bits during the design phase, a sprite can contain up to 4 colors (0-4). The bit pair of 00 will be transparent. The bit pair of 01 will be linked to the color in $D025 (53285). The bit pair of 11 will be linked to address $D026 (53286). Finally the bit pair of 10 will take on the color of a sprite in memory locations $D025-$D02E (53287-53294).
  It is quite tedious to create a sprite on graph paper, but it can be accomplished. Essentially you will divide each area into 3 rows that occupy 8 bytes each and the height will designed the same way. Most people prefer using a Sprite Editor to accomplish this. Windows has made room for a popular editor known as SpritePad. By using this tool, you can quickly create a whole slew of sprites, add their multicolors, and even animate them.
  Sprite Positions
  Commodore 64 Sprites are positioned horizontally and vertically using the registers $D000-$D00F (53248-53263). So for example Sprite 0 could be positioned on the screen in a position ranging from left to right by using memory location $D000. However, there is a limit to the horizontal position up to byte 255. The vertical position of Sprite 0 can be placed using memory location $D001.
  As mentioned earlier, sprites have a limited (due to their width range) area that can be placed on the screen and require another memory location to reset the horizontal position of a sprite’s high byte. The memory location that handles this is $D010 (53264). By passing in a bit from 0-7 here you can set that sprite’s appropriate horizontal most significant bit at that position.
  Each of the Commodore 64 Sprites require the ability to have it turned on or off. The memory location that handles this is $D015. This is accomplished by setting a bit from 0-7 for the appropriate sprite once again. A zero contained here turns that sprite off and a 1 activates it so it displays on the screen.
  A sprite can be expanded to double it’s height with memory location $D017 (53271). The expansion is controlled by setting a bit with a 0 or 1. As identical to the sprite enable function, setting a zero here turns off the expansion, and placing a 1 here will activate the sprite vertical expansion. Often in games, this could be used to create a boss character since they tend to be larger.
  The Foreground Display Priority Register at memory location $D01B (53275) controls when a sprite will exist in front of a foreground or behind it. This is done again, by setting it to bit 0 or 1. If a game contains a multicolor graphics mode, the sprite will be shown behind other sprite graphics even though the priority is set here for the foreground graphics, due to the 01 bit pair being set.
  Sprite Bit Pairs
  A sprite can contain multiple colors within it’s bit pairs using memory location $D01C (53276). To activate this, set bit 1 here, and turn it off by replacing with bit 0. When it is turned on, the sprite shape data is gathered into pairs. Each pair controls a double wide pixel of the sprite display. Since the sprite has had the horizontal resolution reduced, it is now only 12 dots wide. This now allows the ability for using two new colors. According to Mapping the Commodore 64 the four possible combinations affecting these bit pairs get their color from the data below.
  00 Background Color Register 0 (transparent)
  01 Sprite Multicolor Register 0 (53285, $D025)
  10 Sprite Color Registers (53287, $D027-E)
  11 Sprite Multicolor Register 1 (53286, $D026)
  Each sprite also contains the ability to have three foreground colors, which that color being unique to that sprite.
  Sprite to Sprite Collision
  The collision of a sprite is stored in registers ($D01E-$D01F) or 53278-53279 memory registers. There is some conflict when using this register however. Although a sprite can confirm with sprites overlapped each other (bit 1 is set), it is unable to accurately determine a collision when Commodore 64 Sprites are stacked up in a row. When that occurs, this register would still trigger a collision even if they are not touching each other. A collision is tracked when a bit (dot) of a sprite’s data moves over another dot that does not contain zero data in that area. Sprites that utilize this memory area, can also detect a collision even when it climbs behind the border or off the screen. Likewise setting a zero here will usually clear the collision, if multiple sprites are not conflicting with each other.
  Sprite Foreground Collision
  Just like it’s counterpart, memory location $D01F (53279) has the ability to see when Commodore 64 Sprites have collided with the foreground. By checking to see if a bit 0 or 1 is contained here, it can act on that information. Yet there are still conflicts that can occur so use it wisely, ensuring that sprite bits are not crossing over each other.
  A sprite’s multicolor is set within memory locations $D025- $D026 as discussed earlier. It is necessary for the system to find a zero or 1 here so that sprite’s data can be set accordingly. The default color set for $D025 on power up is purple, and $D026 will contain the color black.
  A standard Commodore 64 Sprites color is set and turned off using locations $D027-$D02E (53287-53294) in memory. Each corresponding sprite once again contains a default color when the computer is first turned on, but they can be changed here.
  Sprite Shape Data and Animation
  Memory locations $07F8-$07FF (2040-2047) contain an area that reserves sprite data. This is useful for animation. The data is contained here for each pointer to match the appropriate shape in memory. Each of the Commodore 64 Sprites, ranging from 0-7 occupy it’s own data containment in these memory addresses. The pointer value is multiplied by 64, which is equal to the starting location of that sprite’s data table. A simple calculation as found in Mapping the Commodore 64 is using Sprite 0 at memory address 704 (11*64=704) to point to the appropriate area of memory. This then leaves room for 63 bytes up to memory address 767. By cycling through data contained in these registers, simple animation is quite possible with your sprites.

SPRITES
A sprite is a small moveable object block that can move independently of the background graphics. The VIC chip can display eight sprites on the screen at anyone time. Sprites can be displayed on anyone of the display modes, and they will look the same in all of them. You can have up to 256 different sprites defined at anyone time, but only eight can be displayed at the same time. The sprite to be displayed can be changed by changing a one byte pointer, so animation can be easily performed by quickly switching through a few different sprite patterns. Sprites can be moved very smoothly by simply giving the VIC chip the X and Y coordinates of the upper left comer of the sprite. Sprites have different display priorities. That means that the sprite with a higher priority will ap pear to move in front of a sprite with a lower priori ty. This can be used to give the illusion of three dimensional movement. The priority of a sprite to the background graphics is individually selected for each sprite. If the background is given priority, the sprite will appear to move behind the background graphics.
For instance, if a tree was being displayed in the bit mapped graphics mode, and a sprite in the shape of a dog was to move past the tree, the dog would appear to be moving behind the tree. Each sprite is a block 24 pixels horizontally by 21 pixels vertically. The pixels that are set to one use 1 of the 16 available colors.
The pixels that are set to zero allow the background color to show through (are transparent). Like the other graphics modes, a sprite can be selected to be in the multicolor mode, giving it a resolution of 12 by 21 in three colors plus transparent. Wherever a sprite is transparent, whatever is behind the sprite will show through. For those times when a larger sprite is necessary, the VIC chip has the option of doubling the horizontal size, the vertical size, or both. You will not increase the detail available in your sprite by using one of the multiply options, only the size.
When a sprite is expanded, each of the pixels is twice the size of the pixels in a normal sprite. Sprite Pointers Once a sprite has been defined, the VIC chip needs to be told where to find the pattern. The sprite definition must be in the currently selected bank of memory for it to be displayed. Since each sprite definition takes up 64 bytes, a sprite definition will always start on a $0040 boundary in memory. A 16K bank of memory can hold 256 sprite definitions, so it will only require one byte to tell the VIC chip which sprite to display. The sprite pointer is a number which, when multiplied by 64, will give the starting address of the sprite definition.
Sprite definitions may not be placed in a section of memory where the VIC chip sees an image of the character generator ROM. The VIC chip will read the eight sprite pointers from the last eight bytes of the lK of text memory, 30 an offset of $03F8 from the text base address. Since only 1000 out of 1024 bytes of text memory are used to display characters on the screen, the sprite pointers will not interfere with screen graphics. For example, since the default setting of the text memory is at $0400, the first sprite pointer will be $07F8. Sprite Controls For most of the sprite control registers, each bit in the register corresponds to one of the sprites. For example, bit 0 represents sprite 0, bit 1 represents sprite 1, and so on. The rest of the sprite controls require a value (such as a vertical location), so there is one register for each sprite. Enabling a sprite. Before a sprite can be seen, it must be enabled.
The register SPREN ($DOI5), has an enable bit for each sprite. If the bit is set, the sprite will be enabled. The sprite will only be seen if the X and Y positions are set to the visi ble portion of the screen. A sprite can be disabled by clearing the appropriate bit. Setting the sprite color. There are eight registers that are used to hold color information, one for each sprite. Any of the 16 available colors may be selected for each sprite. Each bit that is set in the sprite definition will cause a pixel to be displayed in the sprite color. If the bit is clear, the pixel will be transparent. The sprite color registers are: Name SPRCLO SPRCLl SPRCL2 SPRCL3 SPRCL4 SPRCL5 SPRCL6 SPRCL7 Address $D027 $D028 $D029 $D02A $D02B $D02C $D02D $D02E Setting the multicolor mode.
The multicolor mode can be individually selected for each ($DOlC)/sprite by setting the appropriate bit in the MLTSP ($DOlC) register. Setting a bit will enable the multicolor mode, clearing the bit will disable the multicolor mode. When the multicolor mode is enabled, the horizontal resolution drops from 24 pixels across to 12 pixels. Each pair of bits in the sprite definition is treated as a bit pair, whose value determines which of the four colors will be selected for the pixel

Pair Description 00 01 10 11 TRANSPARENT, SCREEN COLOR SPRITE MULTICOLOR REGISTER #0 ($0025) SPRITE COLOR REGISTER SPRITE MULTICOLOR REGISTER #1 ($0026) Using the sprite multipliers. Each of the sprites can be expanded in either the X or Y direc tion. When a sprite is expanded, each pixel is displayed as twice the normal size in the direction of the expansion. The resolution of the sprite does not increase, only the size. To expand a sprite in the X direction, the ap propriate bit must be set in the SPRXSZ ($DOID) register. To return the sprite to its normal size, clear and bit. The expansion of a sprite in the Y direction is done in the same way as the X expansion. You must set the appropriate bit in the SPRYSZ ($DOI7) register to expand the sprite. The sprite can be returned to its normal size by clearing its bit in the . SPRYSZ register.
The sprite can also be expanded in both the X and Y directions by setting its bit in both registers. Positioning sprites. Each sprite can be posi tioned independently anywhere on the visible screen and off the visible screen in any direction. Since the screen is 320 pixels wide, it takes more than one byte to specify a horizontal position.
Each sprite has its own X position register and Y position register, and a bit in an extra most significant bit register.
The location specified by the registers is the position where the upper left comer of the sprite will appear.
For an unexpanded sprite to be completely visible, the Y value must be between $32 and $E9. Any other values will place the sprite partially off the screen. Whatever value is placed in the X position register is the least significant 8 bits of a 9 bit value. Each sprite has a ninth bit in the XMSB ($DOlO) register. An unexpanded sprite will be completely visible if the 9 bit X value is greater than $18 and less than $140. The HINC and HDEC macros can be used to perform 9 bit increments and decrements of the X position. Table 7-6 shows the screen coordinates for expanded and unexpanded sprites to be fully visible on the screen. Any sprite positions outside of these limits will be partially or fully off of the screen. This provides an easy way to reveal a sprite gradually. Assigning sprite priorities.
As mentioned before, each sprite has a display priority with respect to the other sprites and to the background. You can create a three dimensional effect by allow ing different sprites to pass in front of each other. The priority of one sprite to another is predeter mined by the VIC chip. Sprite 0 has the highest priority, meaning that it will appear to be in front of all other sprites. Sprite 7 has the lowest priority of all the sprites. Each sprite can be individually selected to either have a higher priority than the background or a lower priority. If the sprite’s bit in the BPRIOR ($D01B) register is clear, the sprite will appear to pass in front of the background. When the bit for the sprite is set in the BPRIOR register, the sprite will appear to move behind the background image and in front of the background color. Because sprites can have transparent as one of their colors, any sprite that passes behind a higher priority sprite with transparent in it will show through in the transparent areas.

Overview of System Memory Map
The System Memory Map plays a vital role in the operation of the computer. It is essentially a blueprint of the computer’s memory, showing the locations of the different memory regions and how they are used. By understanding the memory map, programmers and users can effectively use and manipulate the computer’s resources.
Compared to other Commodore computers, the C65’s memory map is unique. It features a larger address space of 24 bits, allowing for a maximum of 16MB of memory. This was a significant improvement over the 64KB limit of the popular Commodore 64. The C65’s memory map also includes a number of new memory regions, such as the SuperCPU and the burst mode, which were not present in earlier models.
The memory map is organized into different regions, each with a specific function. The first region, known as the Zero Page, contains important system variables and routines used by the computer’s operating system. The next region, the Stack, is used to store temporary data and addresses. The code area contains the main program code, and the data area is used to store program data.
The memory map also includes other regions, such as the I/O area, which is used to communicate with peripheral devices, and the ROM area, which contains read-only memory. By understanding the different regions and their functions, programmers and users can make better use of the computer’s resources and optimize their programs for maximum efficiency.
The System Memory Map is a crucial component of the Commodore C65. Its unique features and organization make it an important tool for programming and using the computer effectively. By gaining a deeper understanding of the memory map, users can unlock the full potential of the C65 and take their computing experience to new heights.
The C65 features a 128-kilobyte ROM that is organized into four regions: the system ROM, the BASIC ROM, the Kernal ROM, and the character ROM. The system ROM contains the C65’s boot code and the code that initializes its hardware, while the BASIC ROM contains the version of Commodore BASIC that was modified for the C65.
The Kernal ROM, on the other hand, contains the low-level routines that interact with the C65’s hardware, such as those used for reading and writing to disk drives and serial devices. The character ROM is responsible for storing the graphics and characters that the C65 can display.
The C65 features a 128-kilobyte ROM that is organized into four regions: the system ROM, the BASIC ROM, the Kernal ROM, and the character ROM. The system ROM contains the C65’s boot code and the code that initializes its hardware, while the BASIC ROM contains the version of Commodore BASIC that was modified for the C65.
The Kernal ROM, on the other hand, contains the low-level routines that interact with the C65’s hardware, such as those used for reading and writing to disk drives and serial devices. The character ROM is responsible for storing the graphics and characters that the C65 can display.
The system ROM is located at memory addresses $E00000-$E3FFFF, while the BASIC ROM is located at addresses $C00000-$C1FFFF. The Kernal ROM is located at addresses $E80000-$EBFFFF, and the character ROM is located at addresses $D00000-$D0FFFF.
When the C65 boots up, the system ROM is the first ROM region that is accessed. The boot code initializes the C65’s hardware and then loads the C65’s version of BASIC from the BASIC ROM into memory. The C65’s Kernal ROM is then used to interact with the hardware and perform low-level operations.
Understanding the organization and functions of each ROM region is essential for programming and effectively using the C65. By having a solid understanding of the C65’s ROM memory map, programmers can take full advantage of the capabilities of this unique and powerful computer.
https://philreichert.org/commodore-c65/system-memory-map.html
Memory-mapped I/O and interfacing To summarize what we have just explain, an input/output port (I/O port) is allocation in the memory map of the computer that can be used to transfer information either from an external device to the computer from the computer to an external device. The type of input/output operations that use sports in the memory map of the computer system is called memory mapped I/O. These ports maybe accessed with any of the instructions in the 6510instruction set that involve a read or write operation. The type of I/O in which from one to eight bits of information are transmitted simultaneously is called parallel I/O. If only one bit can be output at a time, then the I/O operations are described as serial I/O.

References:
https://philreichert.org/commodore-c65/system-memory-map.html
https://www.cadasio.com/post/8-bit-sprites-to-webgl-how-computer-graphics-have-changed-the-world
COMMODORE 64 ASSEMBLY LANGUAGE ARCADE GAME PROGRAMMING
STEVE BRESS
Copyright © 1985 by TAB BOOKS Inc.

Assembly Language Programming with the Commodore 64
Marvin L. De Jong The Scholte Ozarks Pt. Lookout, MO Brady Communications Company, Inc. A Prentice-Hall Publishing Company

The post Write up on Tech Geek HISTORY: Commodore 64 Sprite & Memory Management appeared first on DayDreamin’ Comics.

Tales of Leo Sonnets
King Cor not of ancient breed status Dies and beforehand after the battle in
Moeche ,settles his prides man in Caskatta,and mates with Fiolama and her 29 sister lionesses regaining a the Zy bloodline.
Omaree of the Gobizyan reached 56 brides and all became fruitful in Caskatta .
But the Taurus hated them, for food was scarce after the Tarzac,Molenda ,Virgo/Libra War. Time of Rachael II.the Western hemisphere was dry of land becoming a depreciated desert in which the ancient
Podam Nuv rose an campaign to kill the Zy and Gobizyan bloodlines.
Emaree the XVII last fight now to bring rain to the sewer land so his prides would not starve.The Taurus they ate during war,became too toxic to eat,because of their perversion like Capricorn to perverted to eat of,because they studied Nasira book of dark magic lies,so the Zy and Gobizyan were told by the messenger of Polyganda,Fasha not eat of fleshy perversion, must go to seek Arbulea for refugee and advice and eat of Libra,so they had to move out of Caskatta and war and eat the Hosand Country,and conquer the Libra and eat of Nasira too stop her before Rachael II does

Emaree the XVII
The King of the Zy Kingdom breed 56 Bloodline Prides of not only the Zy Kingdom but the Gobizyan as well. The Polyganda Law was No Leo was to eat off the Taurus nor Sagitarius flesh. Other creatures of the land like Bane Beast to feed from. Bane Beast and Caribou were once scarce in Caskatta flourished for the 56 Prides to eat of.
Skolora pushed Emaree the XVII out of Bismet and the Hosand Country . Podav Nuv an ancient Taurus was still a corrupted Being due to the Blood Coral his Master Hodu Khan held . Podav Nuv was an opportunities that played two sides of Nasira and Skolora’s war campaign in conquering the Western Hemisphere.
Emaree the XVII and his 56 prides fought the Taurus House of Nuvs for 5 years the House of Nuv almost pushed the Leo Army out of Caskatta and Kreestonia .
Skolora pushed the Leo Pride out of Hosand Country and Bismet.
Leo fought valiantly Skolora and the Snow Sagittarius weld the Bow and Arrow and the House of Podam Nuv was Massive Bulls that over powered the Leo Army.

Emaree the XVII sent his 5 of his oldest sons to find Molenda the Terrible to aide them in their cause against the House of Podam Nuv and Skolora mutual threats to Molenda the Terrible.
“ Father , Father Father, your 5 Oldest sons do not know how to find Molenda the Terrible”
Stated one of Emaree the XVII sons
“ You Must find her , the Fa Sha Messenger of Polyganda has come to me & Promised our Pride Victory , I believe One out of 5 of my eldest Sons will become a Prophet that is what the Fa Sha has promised me. You will find Molenda the Terrible on your quest. Molenda the Terrible will aide us in Victory
The Five Leo Princes left Caskatta to search for Molenda the Terrible , Kanal, She Ta, Tin Minsu, and Goth Batel traveled to Estmar with hopes of Wisdom of Arboreal the Enchantress . On their journey Cor’s Bloodline traveled desolute lands and feed off the Caribou . In order to get to Estmar one had to pass Bismet the land of Skolora . The Five Leo Princes knew they would have to fight their way through Bismet so gathered a Leo Pride Party and the Five Leo Princess took their wives with them on the Journey.

The Leo Pride Party consisted of 50 Leo elite killers . It took 5 months to get to Caskatta to Estmar on foot.
It was the dead of Winter and the Snow Sagitarius were not in hibernation period. Out in the Open the Leo Pride Party teeth and paw ravaged Skolora’s army in the Snow and passed to Estmar with no Leo Pride Party unharmed.
Skolora army was vast but restricted to enter Estmar to follow the Leo Pride Party.
Skolora sent for the House of Podam Nuv for answers? Only a Party of Prophets would pass through Bismet unharmed by the Snow Sagittarius Bow and Arrows. Skolora knew it was a Prophet Party he feared Kumans and would never ask for a Kuman’s aide. Skolora knew no Black Magic nor had Magic Casters in his army. Podam Nuv was filled with the Dark One’s power he sent for the House of Podam Nuv to Bismet.

-Book of Podam Nuv
“ The Great and Mighty Skolora send for myself and a party of my House for a 5 month Journey to Bismet. Curious as we meet face to face about a Prophet . A Leo Prophet of Emaree the XVII sons . I told Skolora that a Prophet can only be created by Polyganda with no father and no mother proclaimed by the Fasha . The Mighty Skolora mentioned Tahquan the Sagittarius from the Ottes Clan. Tahquan was born of an Ottes Clan mother and father.
Then I agreed, and felt intimated by this, A Leo Prophet could destroy the House of Nuv and Skolora. We must find this party of Prophets and find the Leo Prophet and kill the Royal Prince of Leos as Rachael the Demon Queen killed Jasmine the Libra Enforcer. House of Nuv Powers came from the Blood Coral Opal -created by the Dark One Kuman. The Blood Coral was the reason why I sustained ancient life . I never feared death or never thought I Podam Nuv could be killed until I found out that a Leo Party hide a Prophet in their Pride.
We journeyed further beyond Bismet into the Estmar the Land of the Dead onto the Hosand Country with a Snow Sagittarius Party. The Sagittarius Party curious of the Libra Temple almost empty of relics and scrolls , the Libra Temple had been ransacked of scrolls during the Rise of Nasira and Reylo the Shiden Roudo.

We entered Estmar and this legendary Guardian of the Underworld never arose in our presence I thought it was a fable to frighten Zodiacs from entering beyond the Hosand Country.
This Legendry Pool of Healing inside the Temple of Libra was all but empty- it was said that our adversary Nasira and her witches drunk the pool empty decades ago.
The Taurus never made it there way up this far into the Western Hemisphere our invasion was halted in Mid Land by the Virgo Brave Ones as I watched the Virgo Brave Ones hack my Master Hodu Khan in pieces. The House of Nuv executed the House of Brita after the Great War only House that Remain was the House of Nuv.

The answers that Leo Prophet Party sought was indeed in Estmar . The Prophet Party knew which Son was the Prophet he was the one that called out to Arboreal the Enchantress. Arboreal the Enchantress arose from the Ground
“Arboreal the Enchantress, we seek your wisdom , we seek Molenda the Terrible?”
Said Goth Batel
“Goth Batel, you seek my dear friend Molenda. She is surrounded by Magic in which this magical protection makes Molenda hard to locate. You seek allies in your campaign against your adversaries. Your answers are beyond the Western Hemisphere you will need a boatman. “
“We are Leo we are incapable of making Man like boats”
Said Kanal
“Leo you would have to journey far beyond Estmar; to the North called Zirgini where the Virgo Brave Ones reside. Find a boatman to sail to Tish and you will find Molenda the Terrible on 10th Month of the Zodiac World Year.”
Said Arboreal the Enchantress

“We meet a Sagittarius on the road to Meoche and Midland he gave us a Letter to give to Molenda the Terrible, a Dark Skinned Sagittarius who was he Arboreal the Enchantress?
Asked Goth Batel

“ Molenda the Terrible’s father his name is Moshac an ancient”
Said Arboreal the Enchantress.

The post Zodiac WORLD: After Tarzac Leo Offspring appeared first on DayDreamin’ Comics.

G_BOXTEXT (22) Rectangular box with formatted graphic text; ob_specpoints to a TEDINFO structure
G_IMAGE (23) Monochrome image;ob_specpoints to BITBLK structure

G_USERDEF (24) User-defined function for drawing a customized object; ob_spec points to a USERBLK structure. (Note: In some libraries this is called G_PROGDEF for a programmer-defined function)
G_IBOX (25) Transparent rectangle that can only be seen if the optional border does not have zero width; ob_spec contains futher information about the appearance
G_BUTTON (26) Push-button text with border for option selection; ob_spec points to a text string with the text that is to appear in the button New as of MagiC Version 3.0: If the object flag WHITEBAK is set, and bit 15 in object status = 0, then the button will contain an underscored character; for this, (high byte & 0xf) of ob_state gives the desired position of the underscore (with a suitable library one can make the underscored character when pressed together with the [Alternate] key select the button in the dialog of a running application) On the other hand if bit 15 = 1 then we are dealing with a special button (radio-button or checkbox) Further specialties: WHITEBAK = 1, bit 15 = 1 and in ob_state: Highbyte = -2 Group frames Highbyte = -1 Special button, no underscore Highbyte != -1,-2 Special button, with underscore (Here again (high byte & 0xf) of ob_spec is the underscore position). The presence of these features is best established via the function appl_getinfo (opcode 13).

G_BOXCHAR (27) Rectangle containing a character; in ob_spec both the appearance of the border and the character are defined
G_STRING (28) Character string; ob_spec points to the string New as of MagiC Version 3.0: If the object flag WHITEBAK is set, and the high-byte of ob_state != -1, then a character of the string will be underscored; the underscore position is determined by (high byte & 0xf) of ob_state With WHITEBAK flag set and high byte ofob_state= -1 the complete string will be underscored. The presence of these features is best established via the function appl_getinfo (opcode 13).

G_FTEXT (29) Editable formatted graphic text; ob_spec points to a TEDINFO structure

G_FBOXTEXT (30) Rectangle with editable formatted graphic text; ob_spec points to a TEDINFO structure
G_ICON (31) Monochrome icon symbol with mask; ob_spec points to the ICONBLK structure

G_TITLE (32) Title of a drop-down menu; ob_spec points to the string. As of MagiC 2 one can also underscore one of the characters. This is done as follows: Set WHITEBAK in ob_state (ob_state >> 8) & 0xf Position of the underscore (ob_state >> 8) & 0xf0 is 0

G_CICON (33) Colour icon (available as of AES V3.3); ob_spec points to the CICONBLK structure

G_CLRICN (33) Colour icon; ob_spec is a pointer to an ICONBLK structure. Supported in the ViewMAX/3 beta and in FreeGEM.

G_SWBUTTON (34) Cycle button (i.e. a button which alters its text cyclically when clicked on); ob_spec points to a SWINFO structure. The presence of this object type should be inquired with appl_getinfo (opcode 13).

G_DTMFDB (34) For internal AES use only: desktop image. The ob_spec is a far pointer to a MFDB structure. Supported in the ViewMAX/3 beta and in FreeGEM.

G_POPUP (35) Popup menu; ob_spec points to a POPINFO structure. If the menu has more than 16 entries, then it can be scrolled. The presence of this object type should be inquired with appl_getinfo (opcode 13). Note: G_POPUP looks like G_BUTTON but the character string is not centred, so as to line up with the other character strings in the menu if possible.
G_WINTITLE (36) This object number is used internally by MagiC to depict window titles. The construction of this object type may change at any time and is therefore not documented.
G_EDIT (37) As of MagiC 5.20 an editable object implemented in a shared library is available; ob_spec points to the object. Warning: This type is not yet supported by the functions form_do, form_xdo, form_button, form_keybd, objc_edit, wdlg_evnt and wdlg_do at present, i.e. the corresponding events need to be passed on to the object (with edit_evnt).

G_SHORTCUT (38) This type is treated in a similar way to G_STRING, but any keyboard shortcut present is split off and output ranged right. The presence of this object type should be inquired for with appl_getinfo (opcode 13). The introduction of proportional AES fonts required new strategy for the alignment of menu entries. So as to align keyboard shortcuts ranged right, objects of the type G_STRING inside a menu are therefore split into commands and shortcuts. This strategy however fails for menus that are managed by the program itself, e.g. within a window or a popup menu. This new object type had to be introduced in order to achieve usable alignment in that case too.
G_SLIST (39) XaAES extended object – scrolling list.
Note: For G_BOX, G_IBOX and G_BOXCHAR, the component ob_spec of the OBJECT structure does not point to another data structure, but contains further information for the appearance of the object. The following apply:
Bits Meaning

24..31 Character to be depicted (only for G_BOXCHAR)
16..23 0 = Border width 1..128 = Border lies 1..128 pixels at the inside of the object -1..-127 = Border lies 1..127 pixel at the outside of the object
12..15 Border colour (0..15)
08..11 Text colour (0..15)
7 Text transparent (0) or opaque (1)
04..06 0 = Hollow 1 = Increasing intensity 2 . . 7 = Solid area
00..03 Inner colour (0..15)
The high byte is used by the AES only for submenus. If the highest bit of ob_type is 0x8000 and the bit SUBMENU in ob_flags is set, then the bits 8..14 specify which submenu is coupled with the menu entry. Hence each application can have a maximum of 128 submenus. MagiC only reads the low byte from ob_type, apart from the submenu handling. TOS reacts cleanly to unknown object types (such as the purely MagiC types G_SWBUTTON etc.), i.e. the objects are not drawn.
See also: Object structure in AES AES object colours
8.2.4.2 AES object colours
The following table contains the predefined object colours. Of course particulars depend on the selected screen resolution, as well as any settings made by the user.
Number Colour Standard RGB values
WHITE (00) White 1000, 1000, 1000
BLACK (01) Black 0, 0, 0
RED (02) Red 1000, 0, 0
GREEN (03) Green 0, 1000, 0
BLUE (04) Blue 0, 0, 1000
CYAN (05) Cyan 0, 1000, 1000
YELLOW (06) Yellow 1000, 1000, 0
MAGENTA (07) Magenta 1000, 0, 1000
DWHITE (08) Light grey 752, 752, 752
DBLACK (09) Dark grey 501, 501, 501
DRED (10) Dark red 713, 0, 0
DGREEN (11) Dark green 0, 713, 0
DBLUE (12) Dark blue 0, 0, 713
DCYAN (13) Dark cyan 0, 713, 713
DYELLOW (14) Dark yellow 713, 713, 0
DMAGENTA (15) Dark magenta 713, 0, 713
Note: These colours also correspond mostly to the icon colours used under Windows and OS/2. With a suitable CPX module one can set the correct RGB values for the frst 16 colours.
See also: Object structure in AES AES object types
8.2.4.3 AES object flags
The manipulation flags of an object determine its properties. The following options can be chosen:
Flag Meaning
NONE (0x0000) No properties.
SELECTABLE (0x0001) The object is selectable by clicking on it with the mouse.
DEFAULT (0x0002) If the user presses the [Return] or [Enter] key, this object will be selected automatically and the dialog exited; the object will have a thicker outline. This flag is permitted only once in each tree.
EXIT (0x0004) Clicking on such an object and releasing the mouse button while still over it will terminate the dialog (see also form_do).

EDITABLE (0x0008) This object may be edited by the user by means of the keyboard.
RBUTTON (0x0010) If several objects in an object tree have the property RBUTTON (radio button, similar to those on a push-button radio), then only one of these objects can be in a selected state at a time. These objects should all be children of a parent object with the object type G_IBOX. If another object of this group is selected, then the previously selected object will be deselected automatically.
LASTOB (0x0020) This flag tells the AES that this is the last object within an object tree.
TOUCHEXIT (0x0040) The dialog (see also form_do) will be exited as soon as the mouse pointer lies above this object and the left mouse button is pressed.

HIDETREE (0x0080) The object and its children will no longer be noticed by objc_draw and objc_find as soon as this flag is set. Furthermore this flag is also evaluated as of MagiC 5.20 by form_keybd, if objects for keyboard shortcuts are searched for. Input to hidden objects is still possible, however. To prevent this, the EDITABLE flag has to be cleared.
INDIRECT (0x0100) ob_spec now points to a further pointer that in turn points to the actual value of ob_spec (see also OBJECT). In this way the standard data structures such as TEDINFO etc. can be extended in a simple way.

FL3DIND (0x0200) Under MultiTOS this object creates a three-dimensional object (under MagiC as of Version 3.0 only from 16-colour resolutions onwards and when the 3D effect has not been switched off). In 3D operation this will be interpreted as an indicator. As a rule, such objects are buttons that display a status, e.g. radio-buttons.
ESCCANCEL (0x0200) Pressing the [Esc] key corresponds to the selection of the object with this flag. Therefore there may be only one default object in a dialog. Only effective in ViewMAX/2 and later.
FL3DBAK (0x0400) In 3D operation this object will be treated as an AES background object, and drawn as such. It is recommended to allocate the ROOT object with this flag in dialogs with 3D buttons. The same applies for editable fields and text objects, as only in this way will a consistent background colour be maintained. See also (0x4000).
BITBUTTON (0x0400) This flag was introduced with ViewMAX beta, but not used there. Presumably a button with this flag contains a bitmap in place of a text. Only effective in ViewMAX/2 and later.
FL3DACT (0x0600) In 3D operation this object will be treated as an activator. As a rule such objects are buttons with which one can exit dialogs or trigger some action.
SUBMENU (0x0800) This is used in MultiTOS and from MagiC 5.10 on to mark submenus. menu_attach sets this bit in a menu entry to signify that a submenu is attached to it. The high byte of ob_typethen contains the submenu index (128..255) i.e. bit 15 of ob_type is always set simultabeously with SUBMENU.
SCROLLER (0x0800) Pressing the [PAGEUP] key corresponds to the selection of the first object with this flag in the dialog; pressing the [PAGEDOWN] key corresponds to the selection of the last object with this flag. Only effective in ViewMAX/2 and later.
FLAG3D (0x1000) An object with this flag will be drawn with a 3D border. From ViewMAX/2 on every button will be drawn automatically with a 3D border. The colour category (see USECOLOURCAT) will be used for this. Only effective in ViewMAX/2 and later.
USECOLOURCAT (0x2000) USECOLOURCAT (0x2000) The colour of the object is not a colour index of the VDI, but an entry in a table with colours for designated categories. This table has 16 entries. ViewMAX uses the following categories: CC_NAME (8) Inactive title-bar CC_SLIDER (8) Scroll bar background CC_DESKTOP (10) The desktop CC_BUTTON (11) Buttons and other 3D widgets CC_INFO (12) Window information-line CC_ALERT (13) Alert boxes (not used in ViewMAX or FreeGEM) CC_SLCTDNAME (14) Active title-bar Probably it is intended to let the categories 0 to 7 be defined by the application, while 8 to 15 are reserved for the system. The settings are stored in ViewMAX.INI (GEM.CFG in FreeGEM) and consist of one foreground, one background, a fill-style and a fill index in each case. Only effective in ViewMAX/2 and later.
FL3DBAK (0x4000) 3D background (sunken rather than raised). To check for this feature, use appl_init and check that bit 3 of xbuf.abilities is set.

SUBMENU (0x8000) Not implemented in any known PC AES.
See also: Object structure in AES AES object types
8.2.4.4 AES object stati
The object status determines how an object will be displayed later on the screen. An object status can be of the following type:
Status Meaning
NORMAL (0x0000) Normal representation.
SELECTED (0x0001) Inverse representation, i.e. the object is selected (except for G_CICON, which will use its ‘selected’ image).

CROSSED (0x0002) If the object type is BOX, the object will be drawn with a white diagonal cross over it (usually this state can be seen only over a selected or coloured object). See also below.
CHECKED (0x0004) A checkmark tick will be displayed at the left edge of the object.
DISABLED (0x0008) The object will be displayed greyed out and is no longer selectable.
OUTLINED (0x0010) The object gets a border.
SHADOWED (0x0020) A shadow is drawn under the object.
WHITEBAK (0x0040) With PC-GEM this causes the icon mask not to be drawn with the icon, which can speed up output is some circumstances. As of MagiC 3 this controls the underscoring of character strings. This feature can be ascertained with appl_getinfo (opcode 13).

DRAW3D (0x0080) An object is to be drawn with a 3D effect. This flag is of interest only for PC-GEM, and will be ignored by the Atari AES (and also in MagiC).
HIGHLIGHTED (0x0100) An object with this status will be surrounded by a dashed line that is drawn with MD_XOR. This status was introduced with ViewMAX beta.

UNHIGHLIGHTED (0x0200) An object with this status will be drawn with the surround explicitly set by the status HIGHLIGHTED removed. For this one has to proceed as follows: First the status HIGHLIGHTED must be cleared, then the status UNHIGHLIGHTED set and following this the object must be redrawn with the function objc_draw. A redraw of the object without the status UNHIGHLIGHTED would not remove the surround, as it lies outside the area that the object occupies. After the redraw the status UNHIGHLIGHTED should be cleared again. This status was introduced with ViewMAX beta.
UNDERLINE (0x0f00) This opcode is available in MagiC from Version 2.0 onwards, and sets the position and size of the underscore for objects of the type G_STRING, G_TITLE and G_BUTTON.

XSTATE (0xf000) This opcode is available in MagiC from Version 2.0 onwards, and serves for switching for the various button types (G_STRING, G_TITLE and G_BUTTON).
In GEM/5, CROSSED makes the object draw in 3D:
• If an object is both CROSSED and SELECTABLE, then it is drawn as a checkbox.
• If it is CROSSED, SELECTABLE and an RBUTTON, it is drawn as a radio button.
• If it is a button or a box and it is CROSSED, then it is drawn as a raised 3D shape, similar to Motif.
• If a button is CROSSED and DEFAULT, a “Return key” symbol appears on it (rather like NEXTSTEP).
• Boxes and text fields that are CROSSED and CHECKED appear sunken.
GEM/5 can be detected by calling vqt_name for font 1. If nothing is returned, GEM/5 is running.
Recent FreeGEM builds contain a system based on the GEM/5 one, but extended and backwards-compatible. The DRAW3D state is used instead of CROSSED:
• If an object is both DRAW3D and SELECTABLE, then it is drawn as a checkbox.
• If it is DRAW3D, SELECTABLE and an RBUTTON, it is drawn as a radio button.
• If a button is DRAW3D and DEFAULT, a “Return key” symbol will be on it.
• If an object with a 3D border has the WHITEBAK state, then the 3D border will not have a black edge.
• If a radio button or checkbox has the WHITEBAK state, then it will be drawn with a white background rather than in the colour used by 3D objects.
To check for these abilities, use appl_init and check that bit 3 of xbuf.abilities is set.
See also: Object structure in AES AES object types
8.2.5 The quarter-screen buffer
The quarter-screen buffer is required by the screen-manager to save the contents of the menu background when drop-down menus drop down. The ‘QSB’ (the usual abbreviation) is also used for the display of alert boxes. Normally its size should depend on the number of colour planes and the size of the system font, but not on the total size of the screen.
A good formula would be:
500(characters) * space of one character * colour planes
In ‘ST High’ resolution this would give a value of exactly 8000 (i.e. a quarter of the screen memory). Unfortunately in many cases the AES is not so clever. The following table contains a summary of the algorithm used by some GEM versions:
GEM version Method for setting the QSB
1.0 and 1.2 Static, 8000 bytes
1.4 Dynamic, a quarter of the screen memory
3.0 Dynamic, half of the screen memory
Note: The GEM versions 1.0 and 1.2 (i.e. up to and including TOS Version 1.02) are not prepared by this for colour graphics cards – one of several reasons why even with the use of a special VDI driver under these GEM versions one can not make use of colour graphics cards.
See also: GEM
8.2.6 The rectangle-list of a window
To overcome the problem of windows that overlap each other, the AES holds for each window a so-called rectangle-list; when a window is partially obscured, GEM divides the visible portion of that window into the least possible number of non-overlapping rectangles, the details of which are then stored in the rectangle-list. Thus the elements of this list form a record of the currently completely visible working area of the corresponding window.
To redraw a window (or its contents) one first inquires with the function wind_get(WF_FIRSTXYWH) for the first rectangle of the abovementioned list. Then one checks whether this rectangle overlaps with the screen area to be redrawn; then and only then one can redraw this area with the use of vs_clip.
This method will be continued with all remaining elements of the rectangle-list, until the height and the width of a rectangle have the value zero.
See also: Clipping WM_REDRAW wind_get wind_update
8.2.7 The screen-manager
The screen-manager is always active and supervises the position of the mouse pointer when this leaves the working area of the window of other applications. The areas in question are the frames of the windows, the drop-down menus and the menu bar.
When touching the menu area, the screen-manager automatically ensures that the section of the screen occupied by the menu is saved and later restored again (the quarter-screen buffer is used for this).
Manipulation of the window controllers also do not lead to permanent changes of the screen memory; the result of the interaction with the screen-manager are the so-called message events, which inform the relevant application about the user’s actions.
Note: The ID of the screen-manager can, incidentally, be found easily by a call of appl_find(“SCRENMGR”).
See also: About the AES GEM Messages
8.2.8 Toolbar support
From AES version 4.1 onwards the operating system supports so-called toolbars. A toolbar is an OBJECT tree that is positioned below the information-line of a window (and above the working area) which makes it possible to display buttons, icons etc. in a window.
As already known from the window routines, the management of toolbars is shared betwen the AES and the application. Here the AES is responsible for the following actions:
• Adaptation of the X- and Y-coordinates of the toolbar when the window is moved or its size is changed.
• Ensuring that the window is configured to the size required by the window components and the toolbar.
• Adjustment of the toolbar’s width to the width of the window.
• Redraw of the toolbar on receipt of a WM_REDRAW message.
• Sending of AES messages when the user activates an object of the toolbar.
The application, on the other hand, must look after the following:
• Construction of an OBJECT tree for the toolbar (in particulat one has to ensure that all selectable elements of the toolbox have the status TOUCHEXIT).
• Adjustment of the width of a toolbar object if this depends on the width of the window (may be required when changing the size of the window).
• Handling of USERDEF objects.
• Redrawing all objects whose appearance is to be changed. In this case it is imperative that the rectangle-list of the toolbar is inquired for and/or taken into account.
• Problems that arise in connection with the screen resolution have to be solved. Thus, for instance, the height of an icon in the ST Medium resolution can differ from the height of the icon in the TT030 Medium resolution.
For supporting toolbars in your own programs, you should respect the following points:
• Communication with the AES window-manager
• Problems with wind_calc
• Redraw and updating of toolbars
• Toolbar support under XaAES
See also:
WF_TOOLBAR WF_FTOOLBAR WF_NTOOLBAR WM_TOOLBAR wind_get wind_set
8.2.8.1 Redraw and updating of toolbars
For redraws of (parts of) the toolbar, one has to pay respect to the rectangle-list as usual. As the previous wind_get opcodes WF_FIRSTXYWH and WF_NEXTXYWH only respect the working area of a window, however, two new parameters (WF_FTOOLBAR and WF_NTOOLBAR) were introduced, with whose help the rectangle-list of a toolbar can be interrogated.
A redraw of (parts of) the toolbar may be necessary in the following situations:
• The toolbar contains user-defined objects (USERDEF‘s).
• The status of an object in the toolbar was altered. The area to be redrawn here consists of the size of the object plus the space required for special effects (3D, shadowing, outlining etc.).
Redraw is not necessary in the following cases, for instance:
• The relevant window is iconified. The application does not have to take on any management of the toolbar; this is only required at the restoration of the iconification, the so-called uniconify.
• The toolbar present in the window is to be replaced by another one. In this case a call of wind_set with the opcode WF_TOOLBAR and the address of the new OBJECT tree will suffice.
• The toolbar present in the window is to be removed. In this case a call of wind_set with the opcode WF_TOOLBAR and NULL parameters will suffice.
See also: Rectangle-list of a window Toolbar support
8.2.8.2 Toolbars and the window-manager
For handling toolbars an application can have recourse to the window- manager of the AES. In detail:
For tacking on a toolbar to a window, it is sufficient to call wind_set(handle, WF_TOOLBAR, …) with the address of the toolbar object tree. If this call is executed while the window is open, then it is itself responsible for the correct calculation of the height of the toolbar.
To exchange a toolbar for another one, one can have recourse to a call of wind_set(handle, WF_TOOLBAR, …) with the address of the new toolbar. If this call is executed while the window is open, then it is itself responsible for the correct calculation of the height of the (new) toolbar.
To remove a toolbar from a window, it is necessary to call wind_set(handle, WF_TOOLBAR, …) with NULL parameters. If this call is executed while the window is open, then it is itself responsible for the correct calculation of the height of the toolbar.
In addition the following points have to be taken into consideration:
• If a window is closed with wind_close, then any toolbar present will not be removed. At a later reopening the toolbar will be in place once more.
• If a window is removed with wind_delete, then its link to a toolbar will be dissolved.
• To be able to recognize mouse-clicks on toolbar objects, these have to possess the status TOUCHEXIT. When such an object is clicked on, the AES creates a WM_TOOLBAR message which is sent to the relevant application.
See also: AES GEM Toolbar support
8.2.8.3 Problems with wind_calc in toolbar windows
When applying the function wind_calc to windows that possess a toolbar there are several problems to be taken into account:
As this function is not passed a window ID (window handle), the desired sizes cannot be calculated correctly when a toolbar is present in the window. The reason for this is that, quite simply, the AES in this case has no information about the toolbar, and specially about its size.
Hence the values returned by wind_calc in such cases have to be further refined by the application. As the program can access the relevant OBJECT tree (and with this also the height of the toolbar), this should present no problems. In detail:
• When ascertaining the border areas of the window, the height of the toolbar must be added to the height returned by the function.
• When ascertaining the working area of the window, the height of the toolbar must be added to the Y-value (couty) returned by the function.
Note: Besides the height of the actual object, the height of the toolbar should include also the space requirement for special effects (3D, shadowing, etc.).
See also: WF_FTOOLBAR WF_NTOOLBAR WM_TOOLBAR objc_sysvar
8.2.9 AES bindings
The AES is called via a single subprogram that is passed 6 parameters; these are addresses of various arrays that are used for input/output communications. To call an AES function, the following parameter block must be populated with the addresses of the arrays described below:
typedef struct
{
int16_t cb_pcontrol; / Pointer to control array */
int16_t *cb_pglobal; /* Pointer to global array */
int16_t *cb_pintin; /* Pointer to int_in array */
int16_t *cb_pintout; /* Pointer to int_out array */
int16_t *cb_padrin; /* Pointer to adr_in array */
int16_t *cb_padrout; /* Pointer to adr_out array */
} AESPB;
The address of this parameter block (which lies on the stack) must be entered in register d1, and subsequently register d0.w must be filled with the magic value 0xc8 (200). With a TRAP #2 system call the AES can then be called directly. For the Pure-Assembler this could look like this, for instance:
.EXPORT aes ; Export function
.CODE ; Start of the code-segment
aes: MOVE.L 4(sp),d1 ; Address of the parameter blocks
MOVE.W #200,d0 ; Opcode of the AES
TRAP #2 ; Call GEM
RTS ; And exit
.END ; End of the module
There is no clear information available about which registers may be altered. In fact, however, the corresponding routines in ROM save all registers.
Now to the individual arrays. With each field, designated input or output functions can be performed. The following apply:
int16_t control[5] With this field information about the called function and its parameters can be determined. The following apply: control[0] = Function number (opcode) control[1] = Number of elements in int_in array the function is being sent control[2] = Number of elements in int_out array the function is being sent control[3] = Number of elements in addr_in array the function returns control[4] = Number of elements in addr_out array the function returns There is no clear information about which elements must be set before an AES call. It is required in each case for elements [0],[1] and [3]. It seems less sensible for the elements [2] and [4] – after all the AES functions know how many values they return in the output fields.
int16_t global[15] This field contains global data for the application and is used partly by appl_init and partly by other AES functions, and is filled automatically. The following apply: global[0] Version number of the AES global[1] Number of applications that can run concurrently; with a value of -1 there is no limit global[2] Unique ID number of the application global[3,4] Miscellaneous information that only has meanning for the application, and can be set and read by it global[5,6] Pointer to a list of pointers to the object trees of the application (is set by rsrc_load) global[7,8] Address of the memory reserved for the resource file. Only documented by Digital Research and not by Atari. global[9] Length of the reserved memory. Only documented by Digital Research and not by Atari. global[10] Number of colour planes. Only documented by Digital Research and not by Atari. global[11,12] Reserved global[13] Maximum height of a character, which is used by the AES for the vst_height call. This entry is only available as of AES Version 4.0, and also only documented by Atari. As of PC-GEM Version 2.0 this value is interpreted as a bit-vector with the drives registered with the desktop (bit 15 = Drive A:). global[14] Minimum height of a character, which is used by the AES for the vst_height call. This entry is only available as of AES Version 4.0, and also only documented by Atari. As of PC-GEM Version 2.0 this value is interpreted as a bit-vector that specifies which of the drives listed in global[13] can be regarded as hard drives.
int16_t int_in[16] All 16-bit-sized input parameters are passed with this field.
int16_t int_out[10] All 16-bit-sized return values are supplied by the AES via this field.
int32_t addr_in[8] This field serves for the transmission of pointers (e.g. pointers to character strings) to the AES functions.
int32_t addr_out[2] All 32-bit-sized return values are supplied by the AES via this field.
Warning: If the operating system supports threads, then it is impera tive that a multithread-safe library is used. In particular one must ensure that each thread receives its own global field (see above).
See also: Sample binding VDI bindings TOS list
8.2.9.1 Sample binding for AES functions
The function ‘crys_if’ (crystal interface) looks after the proper filling of the control arrays, and performs the actual AES call. It is passed one WORD parameter in d0 containing the funtion’s opcode minus 10 multiplied by 4 (for faster table indexing); this gives an index into a table in which the values for control[1], control[2] and control[3] are entered for each individual AES function.
AESPB c;
int16_t crys_if (int16_t opcode)
{
int16_t i, *paesb;
control[0] = opcode;
paespb = &ctrl_cnts[ (opcode-10)*3 ];
for (i = 1; i < 4; i++)
control[i] = *paespb++;
aes (c);
return (int_out[0]);
} /* crys_if */
The table used for this could be built up as follows, for instance:
.GLOBAL ctrl_cnts
.DATA
ctrl_cnts: .dc.b 0, 1, 0 ; appl_init
.dc.b 2, 1, 1 ; appl_read
.dc.b 2, 1, 1 ; appl_write
…
…
…
.END
A fuller version is given in The Atari Compendium pp. 6.39-41. Note that the rsrc_gaddr call must be special cased in a library if you want to use the crys_if binding to call the AES.
See also: AES bindings GEM

Chapter 2

Write up on Tech Geek HISTORY: CP/M (Control Program for Microcomputers)
Introduction
CP/M was a text-based operating system created by American programmer Gary Kindal of Digital Research14. Its initials stood for “Control Program/Monitor” at first, but Digital Research changed it to the more friendly “Control Program for Microcomputers” later.
As the price of microcomputers dropped rapidly in the mid-late 1970s, CP/M, paired with the Z80 CPU became a de-facto standard platform that was popular among small business computers in the late 1970s and early 1980s.
The CP/M family of operating systems is available for both 8- and 16-bit machines and achieved a tremendous degree of success in the years before it was supplanted by the MS-DOS family from Microsoft, which includes the IBM PC-DOS.
Content of the Problem
However, the recent variants, such as Concurrent DOS 386, offer a viable alternative in many situations. However, MS-DOS seems likely to continue to be the dominant single-user operating system, until around 1990 when OS/2 will take over. OS/2 offers multitasking and more sophisticated networking and graphics support. CP/M and Derivatives The first real operating system for microcomputers was CP/M (Control Program for Microcomputers), which was for a long time the dominant operating system with over two million legitimate installations and probably nearer three million including pirates. It is of decreasing importance to PC support staff, as most machines which use it are now being retired, and it is mainly of historical interest, and included in the notes for reference. CP/M was originally written as a spare time project by Gary Kildall as a replacement for paper tape loading of engineering development system software. When Intel Corporation declined to use the system, Kildall licensed the system to Lawrence Livermore Labs, who used it to control nodes in an early network system. It was then picked up by IMSAI, manufacturers of the second microcomputer, and sold as IMDOS, then Cromemco used it.
In 1982, Microsoft Chairman Bill Gates claimed that SoftCard customers represented the largest single install base for CP/M machines. Interestingly, around that same time, a new operating system based on CP/M—Microsoft’s MS-DOS—was rapidly gaining market share.
MS-DOS Borrowed a Lot from CP/M
When IBM began developing its Personal Computer (the IBM PC 5150), the firm first tried to secure a license to CP/M, but Digital Research didn’t like the proposed terms of the deal. So IBM turned to Microsoft, which licensed a product called 86-DOS from Seattle Computer Products (SCP). Some months later, Microsoft purchased 86-DOS outright for $50,000.

Significance of the Study
CP/M is a monitor control Program providing a disc and file handling operating system to stand alone microcomputers. It controls the computer input and output functions. It organizes the files held on disc and reports on the data storage. Finally, it enables you to load and execute programs from disc. CP/M was designed in 1976 for use on a floppy disc-based microcomputer using an 8080 microprocessor. It will only run the 8080,8085 and Z80 microprocessors, it was once the most popular operating systems in the world.
The system was under the control of a monitor holding firmware.
480Z the monitor is called ROS, the Resident Operating System; in the 380Z-D the monitor is called COS, the Central Operating System. CP/M was used to control disc operations on the two different Research Machines Systems. CP/M communicated with either ROS or COS.
The term BIOS was created by:
The Basic Input/Output System the heart of the CP/M, basic disc file operation was to read & write files allocating and reallocating disc space.
The Language was based on Machine Code “Assembly Language.”
CP/M Family CP/M was, however, completed by MAA in 1974.
A file was a single set of data (or information) records that a user gathered and stored on any permanent storage medium. All the work that one did on the microcomputer system was based on disc files.
It included a single- user file system designed to eliminate data IQSS in all but the most unlikely situations, and used recoverable directory information to determine storage allocation rather than a traditional linked-list organization. The simplicity and reliability of the file system was an important kgr-to the success of CP/M: file access to relatively slow floppy disks was im- mediate, and disks could be channeled without losing files or mixing data records. And because CP/M is a Spartan system, today’s increased storage-media transfer rates simply improve overall response.
CP/M was split into five distinct areas, only one of which is machine dependent. The BIOS is the Basic Input Output System, which contains all hardware dependent code to interface with the floppy disk controller, console, etc. The BDOS is the Basic Disk Operating System, which contains the file management system kernel, and is machine independent. The CCP is the Console Command Processor, which is loaded at warm starts to interpret the command line typed by the user at the console. The CCP can be overlaid by application programs. The TPA (Transient Program Area) is where programs are loaded and executed. Transient programs can overlay the CCP, since its functions are not needed by running programs, and they can also overlay the BDOS, provided they do not require its file system services. The Base Page area contains interrupt vectors, certain key variables and vectors to the BDOS and BIOS. Notice that CP/M itself resides at the top end of memory and extends downwards.
CP/M Plus (CP/M 3.0) CP/M Plus brings the bank selection and file system features of MP/M II (see below) to the single-user environment. This version of CP/M is able to manage additional banks of memory in “which it can store the disk directory and track buffers to achieve significantly faster disk accesses (tests indicate up to seven times improvement in accessing indexed files). CP/M Plus also supports a real time clock, permitting data and time stamping of files, as well as password protection, although this consumes disk directory entries. CP/M Plus supports customizable extensions to the operating system called Resident System Extensions (RSX). This allows additional functions to be added to the operating system and called from user programs in the same way as regular system calls. An example of an RSX is the GSX (Graphics System Extension) ANSI standard graphics driver.
CP/M and Derivatives The RMAC macro assembler and SID debugger are supplied as standard with CP/M Plus, since it is customized in a different way. CP/M Plus is rather more user-friendly than 2.2, in that the user no longer needs to type control-C when changing disks, and the system also provides input-output redirection, though in a less sophisticated manner than UNIX.
By the mid-1970s CP/M added a new philosophy to operating system design. CP/M had been implemented on several computer systems, each having a different hardware ‘interface. To accommodate these va & hard- ware environments, CP/M was de- composed into two parts: the .in- variant disk operating system written in PL/M, and a small variant portion written in assembly language.
This separation allowed computer suppliers and end users to adapt their own physical 110 drive to the standard CP/M product. Hard disk technology added yet another factor. CP/M customers re- quired support for disk drives ranging from single 5-inch floppy disks to high-capacity Winchester disk drives. In response, CP/M was totally ~designed in 1979 to become table- driven. All disk dependent parameters were moved from the invariant disk operating system to tables in the variant portion, to be filled in by the system implementer. CP/M is now a multifunction program whose exact operation is defined externally through tables and I/O subroutines. The widespread use of CP/M is directly attributed to this generality: CP/M becomes a special- purpose operating system when it is field-programmed to match an operating environment. Through the efforts of system implementers who provide this field-programming, CP/M was used worldwide in close to 200,000 installations with over 3000 different hardware configurations.
MP/M As single-user CP/M became widely accepted, Digital Research began to develop a new operating system for real-time processing. The design called for a real-time nucleus to support cooperating sequential processes, including a CP/M-compatible file manager with terminal-handling capabilities.
This operating system, called MP/M (Multiprogramming Monitor for Microcomputers), is a further refinement of the process model found in Intel’s RMX and National’s Starplex. As a side effect, the combination of MP/M’s real-time nucleus with the terminal handler and the CP/M file system produces a traditional timesharing system with multiprogramming and multiterminal features.
Timesharing allows programs to execute in increments of processor: time in a “lock-step” fashion. In a timesharing context, a printer pro- gram, often called a spooler, might have the task of printing a series of disk files which result from program output. The spooler starts with a disk-file name and, by using increments of processor time allocated by the real-time nucleus, writes each line from the file to the printer. Upon completion, the spooler obtains another disk-file name and repeats :he process. A disk file to the spooler and, while the file was being printed, the function edited another file in preparation for compilation. The spooler and editor share processor time to complete their respective tasks.
In general, many such processes share processor time and system resources. MP7M process communication is performed through queues (or waiting lines) managed by the nucleus. The spooler, for example, reads file names from an input queue posted by another process (which reads spooler command lines from the console). When the spooler is busy printing a file, additional file names may enter the input queue in a first-in first-out order. Process synchronization through queuing mechanisms is common- place, but MP/M treats queues in a unique manner, simplifying their use and decreasing queue management overhead. Queues are treated as files: they are named symbolically so that a queue can be added dynamically. Like files, queues have queue control blocks that are created, opened, deleted, written, and read. In fact, the set of queue operations closely
A matches the file functions of CP/M so that MP/M provides a familiar programming environment. The implementation of queues is transparent to an operator or system programmer, but it is important to MP/M’s effective operation on limit- ed-resource computers. Queues are implemented through three different data structures, depending upon the message length. So-called “counting semaphores” count the occurrence of an event with message length zero, and are implemented as 16-bit tallies. Single-byte messages are processed using a circular buffer. Similarly, queues containing addresses are processed using circular buffers. In all other cases, Mf /M uses a general linked list, which requires additional space and processing time. It is this sensitivity to the capabilities of limited -resource computers that makes MP/M effective: while real- time operating systems often incur 25 to 40% overhead, MP/M has been streamlined to increase available compute time by 7% over single-user CP/M. Like CP/M, MP/M is separated in- to variant and invariant portions. The file-system interface is identical to that of CP/M, with the addition of user defined functions to handle non- CP/M operations (such as control of the real-time clock). Field-reconfiguration of MP/M allows a variety of device protocols including CP/M- style busy-wait loops, polled devices, and intempt-driven peripherals. In fact, the variety of interface possibilities makes the MP/M implementer a true system-software designer, since a fine-tuned MP/M system may operate considerably faster than its initial implementation. What are. the refinements found in MP/M? First, it is a state-of-the-art operating system based on current process-synchronization technology and microprocessor real-time system design philosophies. Process communication is conceptually simple and requires minimal overhead. Finally, it is the only operating system of its type that can be field- tailored to match almost any computer configuration.

Chapter 3
Write up on Tech geek history: Kermit(File Transfer Protocol)
Introduction
Kermit is the name of a file-transfer protocol and a suite of computer programs for many types of computers that implement that protocol as well as other communication functions ranging from terminal emulation to automation of communications tasks through a high-level cross-platform scripting language.
The software is transport-independent, operating over TCP/IP connections in traditional clear-text mode or secured by SSH, SSL/TLS, or Kerberos, as well as over serial-port connections, modems, and other communication methods.
Literature Review
History
At the height of the timesharing era at Columbia University, about 1980, our central computers began to suffer from a glut of files. Disk storage space was running out, and increasing numbers of students wanted to keep the computer files they accumulated over their academic careers. The problem could not be solved simply by buying more disks because, as somebody’s law states, ‘‘Usage will expand to consume all available resources2.’’ A more decentralized approach was called for. Given the means, those who cared about saving their files from term to term would take the trouble to do it themselves. The newly popular floppy-disk-based microcomputers fit the bill nicely. The diskettes were cheap, capacious, and easily carried and stored. But how could files be transferred reliably from the university’s central computers to the microcomputer floppies, and back? The problem took on a new dimension with the introduction of the IBM PC in 1981, which struck a powerful blow to centralized computing. As the new generation of personal computers began to rival the large central computers in several key application areas, PCs (not only IBM) began to appear in offices all over campus, and soon spread to the homes and dormitory rooms of faculty and students. The users of these PCs needed to communicate and share their work — professors and students, This is a corollary to Parkinson’s Law, which says that ‘‘Work expands so as to fill the time available for its completion.
The Kermit File Transfer Protocol researchers or authors in collaboration, administrators up and down the ‘‘chain of command.’’ Communication was required between PCs and the central systems, between PCs and other (possibly incompatible) PCs, and between our central systems and minicomputers in the academic departments. In short, everything had to ‘‘talk’’ to everything else. But how? Computer networks were not a practical alternative in 1981, and today they remain a costly one, even when you can find a network that provides the required connections. The only medium that all our computers had in common was the ‘‘communication port,’’ the place where a terminal or a ‘‘modem’’ is attached. The operation of the communication port is relatively well defined and standardized, but it is not an ideal medium for bulk transfers of data (for reasons that will be covered later). On the other hand, it is usually standard equipment; with appropriate software it can do the job for little or no additional hardware expense. Several communication software packages were on the market in 1980-81, but they were not available for all our systems. Even if they had been, the total cost would have been enormous when multiplied by the number of microcomputers, minicomputers, and mainframes we expected to arrive in the ensuing years. And even if the cost were bearable, it would not have been wise to depend upon a single commercial vendor for such an important function — the company could fail, or raise its prices suddenly, or decline to add support for some new system. Had we been aware of public domain communication protocols and programs, particularly MODEM3 and its derivatives, we might have been tempted to adapt them to our needs. But it turns out that MODEM would not have fulfilled one of our most basic requirements: IBM mainframe communication. Finally, for better or worse, we took the do-it-yourself approach. We invented a new protocol and called it Kermit, after Kermit the Frog, star of THE MUPPET SHOW .
As luck would have it, the few types of systems that our protocol initially had to support — DECSYSTEM-20 and IBM 370-Series mainframes, CP/M and MS-DOS microcomputers — exhibit among them nearly every imaginable quirk and idiosyncrasy of communication style and file organization, and our protocol was designed to encompass all of them. The result has turned out to be adaptable to almost every new situation; its flexibility accounts in large measure for its popularity. It must be said, however, that had we known Kermit would eventually spread all over the globe (and 3MODEM is more properly referred to as the Christensen protocol; MODEM, XMODEM, and so on, are names of programs that implement this protocol. The Kermit and Christensen protocols are compared in detail on page 314. 4Why? Mostly because there was a Muppets calendar on the wall when we were trying to think of a name, and Kermit is a pleasant, unassuming sort of character. But since we weren’t sure whether it was OK to name our protocol after this popular television and movie star, we pretended that KERMIT was an acronym; unfortunately, we could never find a good set of words to go with the letters, as readers of some of our early source code can attest. Later, Bill Catchings noticed while looking through a name book for his forthcoming baby that Kermit was a Celtic word for free, which is what all Kermit programs should be, and words to this effect replaced the strained acronyms in our source code (Bill’s baby turned out to be a girl, so he had to name her Becky
Kermit is one example of why it’s good to share software of general utility (two others are EMACS [28] and TEX [20]). If we had elected to keep it to ourselves, or to license and sell it, or to keep the source code or protocol specification secret, it would never have reached its current level of popularity. It would never have been written for so many different computers. It would not have improved and evolved through the continuous contribution of bug fixes and new versions, complaints and suggestions. It would never have threatened to become a ‘‘de facto standard.’’ If the spirit of the ’80s is ‘‘Don’t give away anything you can sell,’’ then Kermit must be a child of the ’60s. Contrary to what you might expect from the foregoing polemic, Kermit programs are not necessarily in the public domain. On the contrary, many of them bear copyright notices to protect their authors or sponsoring institutions against having their work turned into commercial products. However, these copyright notices generally grant permission to any individual or organization to use, copy, modify, or redistribute the program, source code, or documentation as long as this is not done for profit, and the copyright notice and author credits are retained. Commercial hardware and software vendors are allowed to add Kermit protocol to their products provided they do not charge their customers extra for it (at least not beyond the incremental cost of reproduction and distribution), and they agree to certain other easy terms. Kermit distribution began at Columbia in 1981. Our original policy was ‘‘send us a tape and a return mailer and we’ll send you the Kermit distribution.’’ Since we were not able to make floppy disks in a wide variety of formats, we preferred to send tapes to institutional computing centers, which could take the responsibility for ‘‘bootstrapping’’ the desired microcomputer implementations to floppy disk and distributing them in appropriate formats to their users. By early 1983 the demand for Kermit tapes had grown far beyond our capacity to produce them and still do our ‘‘real jobs.’’ To get our system programmers out of the shipping room, we began to charge a distribution fee. This fee is not a software license fee. It allows us to keep up with demand by hiring production workers, and it compensates us for media, packaging, postage, computer utilization, and printing. It does not reflect the amount of software on the tape, the quality of the software, nor the amount of effort that went into producing the software — only the ‘‘parts and labor’’ required for reproduction and shipping.
The Kermit File Transfer Protocol For the benefit of those who have trouble with the fee, every effort is made to funnel Kermit programs into alternative distribution channels. Kermit programs are submitted regularly to user group libraries, and they are available on many computer networks and dialup bulletin board systems. All who have received Kermit programs from Columbia or elsewhere are encouraged to share them with their friends and neighbors. Kermit has been an encouraging example of international cooperation on a personal and institutional level.
Kermit runs happily in both Irelands, both Chinas, both Germanys. It can be found in the USA and the USSR, in Israel and Iraq; in New Zealand and New Caledonia, Chile and Czechoslovakia; in Malaysia and Mexico, Sweden and Switzerland, Norway and the Netherlands, and practically anywhere else you can think of. If a country has computers, many of them are probably running Kermit programs — people’s basic needs are pretty much the same everywhere, and people who use computers have begun to view the ability to transmit computer data as a basic need, even a right. Kermit fosters the free exchange of information and ideas, and it works against the trend towards information as commodity (or controlled substance). Our attitudes about sharing spring from a spirit of respect for fellow humans and other creatures. I trust and urge that Kermit be used only for peaceful and humane purposes. It was not created and shared to further causes of nationalism, war, oppression, or discrimination. Please use it in the spirit in which it is offered. Kermit Versus Networks You have probably read about computer networks. Networks are based upon dedicated physical connections between computers; they are the best way to put computers into communication with each other. They’re reliable, they’re fast, they support a variety of functions, and they’re easy to use. They overcome all the same problems that Kermit must cope with, and they do it better. So why bother with Kermit? If you have a network, and it includes all the computers you care about, then you don’t have to bother with Kermit. But networks are expensive, hard to install, and often designed to work only with a particular vendor’s equipment. Many microcomputers have no network option available; even when there is one, the expense can be prohibitive. And when the expense is tolerable, the logistics get in the way — cables must be laid, holes drilled, satellites launched. So chances are that your microcomputer is not on a network, or if it is, that some day you will need it to communicate with some other computer that is not on your network. Network connections must be installed by ‘‘management.’’ They require special ‘‘interface hardware,’’ operating system software, and so forth. Kermit programs, on the other hand, run (with very few exceptions) in the computer’s ‘‘user mode,’’ with no special privileges or changes to the system software required. Once you have a copy of Kermit on your computer, you can establish your own connection to any other computer that you can dial on the telephone or reach with a cable. Unlike proprietary Introduction networks, Kermit always comes with source code and documentation, so even if there is no Kermit program for your computer, a programmer can create one in a short time based on the Kermit programs that have already been written or the examples in this book. Networks are becoming increasingly widespread and interconnected, but they will never encompass every computer in the world. Communication programs like Kermit will always be needed to make the connections that aren’t already there: from home to work, from business trip to home base, from space to earth
Over the years, the Kermit Project grew into a worldwide cooperative nonprofit software development and distribution effort, headquartered at and coordinated from Columbia University. The Kermit Project is dedicated to production of cross-platform, long-lasting, standards-conformant, interoperable communications software, and is actively engaged in the standards process. Kermit software is used all over the world in every sector of the economy.
Although terminal emulation has been largely supplanted by the Web for online access, Kermit software continues to play a role in other applications such as remote sensing and data collection, remote management and troubleshooting of networking and telecommunications equipment, cargo management, medical insurance claim submission, electronic funds transfer, and online filing of income tax returns. Kermit software is embedded in cash registers, network routers, cell-phone towers, medical diagnostic and monitoring equipment, die-cutting and stamping presses, even cardiac pacemakers.
The Kermit protocol and software are named after Kermit the Frog, star of the television series, The Muppet Show; the name Kermit is used by permission of Henson Associates, Inc.
Significance of the Study
ATARI KERMITS
The eight-bit Atari version of Kermit, by John Palevich, was written in ACTION! and then compiled. (You don’t need the ACTION! cartridge to use the program.) This Kermit is available through the Antic Arcade Catalog. Kermit is also a part of Palevich’s Chameleon Terminal Emulator. Also available through the Antic Arcade Catalog ($19.95, AP113).
A 520ST version of Kermit came with our ST development package. Its one-letter command format is very similar to UNIX Kermit.
We got both Kermits running in matching configuration on both our ST and an Atari 800 (it could have been any other 8-bit Atari). Then we ported Listing 1 over to the ST. The listing is a simple Atari Logo program that draws a star against a randomly selected background color.
HARDWARE
We used a printer cable, a null modem connector, a gender changer (female-female) and a modem cable (RS-232 to D9) to attach our ST to Port R1 of an 850 interface. See Figure 1.
SOFTWARE
We booted Kermit on the 800 and set the following parameters:
A – Back S sends (Cursor left (ASCII))
B – Baud.Rate (9600)
C – Carriage return includes line feed is (off)
D – Default disk drive (D1:)
F – File type (text)
I – I/O Port (1)
T – Dialing method (tone)
L – Local Echo (off)
P – Parity (none)
Meanwhile, we loaded the ST Kermit program from GEMDOS and typed KERMIT R which put the ST into the Kermit Receive mode.
Back at the 800, we typed S [RETURN], entered the filename of our logo program and pressed [RETURN] again to begin the transfer.
An instant later, the transfer was over. At 9600 baud, our logo file and its filename, had been “Kermited” from the 800 to our ST and automatically written to the ST’s disk. At 9600 baud, Kermit ports files very rapidly. In fact, you’d have to type for more than four hours at 40 words per minute to match the amount of information ported during a 60-second file transfer.
OPERATIONS
Most Kermits support three commands: Send, Receive and Serve. Kermit Send and Kermit Receive are used when there is a human operator present at each computer. One operator will Send while the other Receives. Most Kermits also support wildcards in filenames. For example, to port all files with a .TXT extender, you’d type *.TXT as the filename to transfer.
The Kermit Server puts one computer on “remote control,” allowing both computers to be controlled by a single operator.
Type KERMIT V to place the St into the Kermit Server mode. While in this mode, the ST will automatically receive any files (and filenames) sent to it, and save each file to disk.
MODIFYING FILES
Our sample Logo file needed only one modification before it could run on the ST. The ST Logo didn’t permit multiple drawing pens. We removed the pen number from the second line of the STAR procedure, changing that line from SETPC 1 :COLR into SETPC :COLR and the program ran correctly.
Since then, we’ve Kermited many more Logo files, LISTed BASIC programs and numerous text files to and from the Antic 52OST.
Listing 1
TO STAR :LN :COLR
SETPC 1 :COLR
REPEAT 36 [RT 170 FD :LN]
END
TO MAIN :COLR
HOME
SETBG RANDOM 16
CLEAN
FS HT PU FD 90 PD
MAKE “LN :COLR
STAR :LN :COLR
MAKE “COLR :COLR + 1
IF :COLR = 16 [MAKE “COLR 1]
MAIN :COLR
END

Chapter 3

1. Background
   The Kermit file transfer protocol is intended for use in an environment where there may be a diverse mixture of computers — micros, personal computers, workstations, laboratory computers, timesharing systems — from a variety of manufacturers. All these systems need have in common is the ability to communicate in ASCII over ordinary serial telecommunication lines. Kermit was originally designed at Columbia University to meet the need for file transfer between our DECSYSTEM-20 and IBM 370-series mainframes and various microcomputers. It turned out that the diverse characteristics of these three kinds of systems resulted in a design that was general enough to fit almost any system. The IBM mainframe, in particular, strains most common assumptions about how computers communicate.
2. Overview
   The Kermit protocol is specifically designed for character-oriented transmission over serial telecommunication lines. The design allows for the restrictions and peculiarities of the medium and the requirements of diverse operating environments — buffering, duplex, parity, character set, file organization, etc. The protocol is carried out by Kermit programs on each end of the serial connection sending “packets” back and forth; the sender sends file names, file contents, and control information; the receiver acknowledges (positively or negatively) each packet. The packets have a layered design, more or less in keeping with the ANSI and ISO philosophies, with the outermost fields used by the data link layer to verify data integrity, the next by the session layer to verify continuity, and the data itself at the application level. Connections between systems are established by the ordinary user. In a typical case, the user runs Kermit on a microcomputer, enters terminal emulation, connects to a remote host computer (perhaps by dialing up), logs in, runs Kermit on the remote host, and then issues commands to that Kermit to start a file transfer, “escapes” back to the micro, and issues commands to that Kermit to start its side of the file transfer. Files may be transferred singly or in groups. Basic Kermit provides only file transfer, and that is provided for sequential files only, though the protocol attempts to allow for various types of sequential files. Microcomputer implementations of Kermit are also expected to provide terminal emulation, to facilitate the initial connection. More advanced implementations simplify the “user interface” somewhat by allowing the Kermit on the remote host to run as a “server”, which can transfer files in either direction upon command from the local “user” Kermit. The server can also provide additional functionality, such as file management, messages, mail, and so forth. Other optional features also exist, including a variety of block check types, a mechanism for passing 8-bit data through a 7-bit communication link, a way to compressing a repeated sequence of characters, and so forth. As local area networks become more popular, inexpensive, and standardized, the demand for Kermit and similar protocols may dwindle, but will never wither away entirely. Unlike hardwired networks, Kermit gives the ordinary user the power to establish reliable error-free connections between any two computers; this may always be necessary for one-shot or long-haul connections
   Kermit is a public domain telecommunications program that lets different types of computers and operating systems swap text files with each other. Thus, software developers may write their applications on one machine and transfer the completed source code to another. Because GEM offers compatibility between different co-processors, there are many companies developing software on the IBM PC who will use Kermit to transfer their C language source code files to the Atari ST.
   MUPPET SOFTWARE
   Named aftcr Kermit the frog, this file transfer protocol monitors the flow of information between computers. Kermit can best be compared to XMODEM protocol. Files transferred through either of these protocols are broken into pieces, or “packets,” and sent individually. A checksum, similar to a TYPO II code, accompanies each packet.
   Each time the computer receives a packet, it recomputes the checksum, and compares it against the sending computer’s original. If the two checksums match, Kermit assumes the packet was received correctly.
   If the checksums don’t match, Kermit will send the packet again and again, until a rnatch is achieved. Kermit continues sending and checking packets until an entire file is successfully transferred.
   Kermit was developed by Bill Catchings and Frank da Cruz at Columbia University in 1981. The first Kermit implementation linked a DEC-20 mainframe to a CP/M-80 microcomputer. Today, more than fifty types of mainframe and micro-computers have Kermit programs

Chapter 4
Write up on Tech Geek History: Motorola 6800
Introduction
Background of the Study
The Motorola 6800, introduced in 1974, is one of the pioneering microprocessors that played a pivotal role in the evolution of computing. As one of the first microprocessors to gain significant market traction, the 6800 influenced numerous applications in both consumer electronics and industrial automation. This article explores the historical context, architectural design, key features, applications, and lasting legacy of the Motorola 6800.
The early 1970s marked a turning point in the field of computing. Microprocessors were emerging as a revolutionary technology, enabling the development of smaller, more affordable computers. Before the introduction of the 6800, many computers relied on discrete transistor technology, which was costly and cumbersome. Motorola recognized the potential for a compact, efficient microprocessor that could power the next generation of computing devices.
Significance of the Study
Development
The 6800 was developed by a team at Motorola led by Dr. Robert Noyce, a co-founder of Intel and a pioneer in semiconductor technology. The design aimed to create a microprocessor that could compete with existing offerings, such as Intel’s 8080 and the Zilog Z80. Motorola focused on creating a processor that was not only powerful but also cost-effective and user-friendly.
The result was a microprocessor with an elegant architecture, low power consumption, and a comprehensive instruction set. It was packaged in a 40-pin dual in-line package (DIP), allowing for easy integration into various devices.
Market Impact
The 6800 quickly gained popularity in various industries, becoming the foundation for several early personal computers and embedded systems. Companies like Apple, Atari, and Commodore adopted the 6800 for their products, marking a significant moment in the history of computing. The processor’s affordability and performance enabled hobbyists and small manufacturers to develop innovative computing solutions, setting the stage for the personal computing revolution.
Architecture of the Motorola 6800
The architecture of the 6800 is characterized by its simplicity, efficiency, and versatility. Below, we delve into its key components, features, and capabilities.
Registers
The 6800 microprocessor features a set of registers that are essential for its operation. These include:

1. Accumulator (A): The primary register used for arithmetic and logical operations. The accumulator holds the data being processed by the microprocessor.
2. Index Registers (X and Y): These registers are used for indexed addressing modes, allowing for efficient data manipulation and array handling.
3. Stack Pointer (SP): The stack pointer points to the current top of the stack in memory, enabling the microprocessor to manage subroutine calls and interrupts.
4. Program Counter (PC): The program counter holds the address of the next instruction to be executed, allowing for sequential execution of instructions.
5. Condition Code Register (CCR): This register contains flags that reflect the status of the processor, including zero, carry, overflow, and negative flags.
   Instruction Set
   The Motorola 6800 boasts a rich instruction set comprising 56 instructions. These instructions can be categorized into several groups:
6. Data Movement: Instructions that move data between registers and memory. Examples include LDA (Load Accumulator) and STA (Store Accumulator).
7. Arithmetic Operations: Instructions that perform basic arithmetic operations, such as ADC (Add with Carry) and SBC (Subtract with Carry).
8. Logic Operations: Instructions that perform bitwise operations, including AND, OR, and EOR.
9. Control Flow: Instructions that alter the program’s execution flow, such as JMP (Jump) and BRA (Branch).
10. Branching Instructions: Instructions that allow for conditional execution, such as BEQ (Branch if Equal) and BNE (Branch if Not Equal).
    Instruction Set
    This processor has an instruction set of only 72 instructions. The instructions + operands range with a usual size of between 1 to 3 bytes. At this size and simplicity, even putting together a simple program without an assembler could be done. Many instructions are variations on the same high-level operation with a different addressing mode. For my task goal, I don’t need to get deep into understanding of the instruction. I just needed to know what is a 1 byte operation that I could do without any additional hardware or memory needed. Many processors support an instruction often called nop, standing for “No Operation.” This instruction, as its name suggest, does nothing beyond take up space. My plan was to hard-wire this instruction into the system. This would let it run without any RAM and without causing any faults or halting conditions.
    For this processor, the numerical value for the nop instruction is 0x01. This is an easy encoding to remember. To wire this instruction in the circuit, I only need to connect the least significant bit of the processor’s data line to a high signal and tie the other ones to a low signal.
    Addressing Modes
    The 6800 supports several addressing modes, which determine how the processor accesses memory. These modes include:
11. Immediate Addressing: The operand is specified directly in the instruction. For example, LDA #$10 loads the value 10 into the accumulator.
12. Zero Page Addressing: This mode accesses memory in the first 256 bytes (zero page) for faster access. For example, LDA $20 loads the value from memory address $20.
13. Absolute Addressing: This mode allows access to any memory location directly using a 16-bit address. For example, LDA $1234 loads the value from memory address $1234.
14. Indexed Addressing: This mode uses index registers to access memory. For example, LDA $20, X loads the value from memory address $20 + X.
15. Indirect Addressing: This mode accesses memory indirectly through a pointer stored in a specified location. For example, LDA ($00) loads the value from the address pointed to by the value at $00.
    Performance
    The Motorola 6800 operates at clock speeds typically ranging from 1 MHz to 2 MHz, depending on the variant. The efficiency of the architecture allows it to execute instructions in a variable number of clock cycles, contributing to its performance. The simplicity of the design, combined with its robust instruction set, enabled the 6800 to perform a wide range of computing tasks effectively.
    Applications of the Motorola 6800
    The 6800 microprocessor has been widely used in various applications across multiple industries, solidifying its status as a classic processor. Some notable applications include:
    Home Computers
16. Apple I and II: The original Apple computers utilized the 6800 architecture, paving the way for the personal computing revolution. The Apple II, in particular, became one of the most successful home computers, featuring advanced graphics and sound capabilities.
17. Atari Consoles: The Atari 2600, released in 1977, relied on the 6800 for its gaming capabilities, contributing to the popularity of home gaming.
18. Commodore PET: The Commodore PET was one of the first all-in-one personal computers, powered by the 6800. Its user-friendly design and built-in monitor made it popular among educational institutions and hobbyists.
    Embedded Systems
    The 6800 found extensive use in embedded systems due to its low cost and efficiency. Applications included:
19. Automotive Control Systems: Many early automotive control systems employed the 6800 for tasks such as engine management and dashboard displays, enabling advancements in automotive technology.
20. Consumer Electronics: The 6800 was integrated into various consumer devices, including microwaves, washing machines, and home appliances, allowing for automation and control.
21. Industrial Automation: The 6800 was used in programmable logic controllers (PLCs) and other industrial applications, enabling improved efficiency and automation in manufacturing processes

Chapter 5
Write up on tech geek HISTORY: VISICALC
Background of the Study
Introduction
Daniel Singer Bricklin was born on the 16th of July in 1951 to a Jewish family living in Philadelphia Pennsylvania. He started programming while still in grade school at Akiba Hebrew Academy. To get a sense of who he was as a child, he wrote some extensions of FORTRAN for a science fair project. After high school, Bricklin attended MIT for mathematics, but quickly changed his major to computer science. He earned his degree in 1973. He then chose to attend Harvard Business School in pursuit of his MBA. He had seen something akin to the Mother of all Demos by Doug Engelbart, and then sitting in room 108 of Aldrich Hall, he daydreamed:
Imagine if my calculator had a ball in its back, like a mouse… imagine if I had a heads-up display, like in a fighter plane, where I could see the virtual image hanging in the air in front of me. I could just move my mouse/keyboard calculator around on the table, punch in a few numbers, circle them to get a sum, do some calculations, and answer ‘10% will be fine!’
The first prototype was in BASIC on Harvard Business School’s timesharing system in Spring of 1978. This prototype is where he figured out the rows, the columns, human-friendly naming for columns, and the status line. Riding his bike around Martha’s Vineyard in the summer of 1978, he decided he would build the product. The first home micro prototype did away with the thought of a mouse. He was working with an Apple ][ borrowed from Dan Fylstra of Personal Software, and he chose to use the arrow keys. Switching between horizontal and vertical movement was done with the space bar. This prototype was written in a weekend using Apple’s BASIC. It was rough, but it did have the columns, the rows, and the arithmetic. At this point, Bricklin’s friend, Bob Frankston, joined him in this endeavor and they took the program from prototype to polished product in two months over the winter of 1978/79.
Significance of the Study
1.1 This final product was written in 6502 assembly for the Apple II . Interestingly, for this step, the programming was done using a macro assembler for the 6502 that ran on MULTICS at MIT, which was accessed via a modem and a DEC Writer III LA-120. Due to the cost of time on the computer at MIT, development was done at night. Eventually, Bricklin and Frankston would have more hardware to write and test, and this development setup would no longer be needed.
VisiCalc was rapidly ported to both newer and older computers. Throughout 1980, VisiCalc was released for the the TRS-80 Model III, the Apple III, the IBM PC, the TRS-80 Model 2, the Commodore PET, the HP 125, and the Atari 800. 1981 saw a port to the Sony SMC-70.
1.2
Overview: The “Electronic Worksheet” The VisiCalc program was born out of the observation that many problems are commonly solved with a calculator, a pencil, and a sheet of paper three nearly universal tools. Calculating sales projections, income taxes, financial ratios, your personal budget, engineering changes, cost estimates, and balancing your checkbook are done with these tools. The VisiCalc program combines the convenience and familiarity of a pocket calculator with the powerful memory and electronic screen capabilities of the personal computer. With the VisiCalc program, the computer’s screen becomes a “window” that looks upon a much larger “electronic worksheet.” You can move or “scroll” this window in four directions to look at any part of the worksheet, or you can split the computer screen into two “windows” to see any two parts of the worksheet at the same time.
The worksheet is organized as a grid of columns and rows. The intersecting lines of the columns and rows define thousands of entry positions. At each position you can enter an alphabetic title, a number, or a formula to be calculated. Just by “writing” on the worksheet, One can set up your own charts, tables, and records. The formatting commands let one individualize the appearance of each entry, row, or column.
One could make your VisiCalc checkbook record look just like your bank statement.
But the power of the VisiCalc program lies in the fact that the computer remembers the formulas and calculations you use in solving a problem. If one changed a number you had previously written on the electronic worksheet, all other related numbers on the worksheet change before your eyes as the VisiCalc program automatically recalculates all of the relevant formulas. Recalculation makes the VisiCalc program a powerful planning and forecasting tool. You can correct mistakes and omissions, and examine various alternatives – effortlessly.
1.3
VisiCalc was the first program to employ an interface of columns and rows to create spreadsheets like those used in analog accounting books. VisiCalc’s Data Interchange Format (DIF) allowed users to enter and manipulate data without coding knowledge, making it easier to use computers for calculations and broadening the appeal of personal computers. Created by Daniel Bricklin and Robert Frankston and released in 1979, VisiCalc would be pivotal in establishing the personal computer as a viable tool for business and accounting purposes.
VisiCalc provides a method for storing data from a spreadsheet onto a special kind of disk file, called a DIF file. DIF stands for Data Interchange Format. The reason DIF is so special is that it stores data in such a way that it can be read by the VisiCalc program or by a BASIC program that you write yourself (or, for that matter, by any number of other programs that you may use on your computer.) In short, DIF files provide a THE VISICALC PROGRAM AND YOUR COMPUTER means of trading data between various programming tools
The three kinds of data entry into the VisiCalc program result in two types of data. Values are numerical data; labels are non numerical. Value references, which are the building blocks of formulas, result in numerical values.
1.4
ENTERING DATA There are three different kinds of data entry into the VisiCalc program, but they result in only two different types of data. Labels essentially represent nonnumeric data. Values and value references represent numeric data. In addition, value references can be used to build formulas for your worksheet. Put simply, a value reference is a way of duplicating the contents of any position on your spreadsheet for use in another position.
All of the functions have one thing in common. You had to enter a special “flag” character to alert the VisiCalc program of your intention to use a function. This flag is the “at” symbol on your keyboard (@). You must type this symbol as the first character of any of the functions; for example:
@SUM
@AVERAGE
@SIN
@MAX
VisiCalc had many functions that Microsoft Excell displays in its Formula Software.
VisiCalc became the first program on a personal computer to be responsible for driving sales of an entire system. By chance, the program’s developers used a borrowed Apple II to develop the program, and as a result that was the first system for which the program was released. When VisiCalc became available, sales of the previously struggling Apple II spiked, which was a boom for the company and made VisiCalc the first “killer app.”
Conclusion
By 1981 Software Arts, the company started by Bricklin and Frankston, had made over $12 million in royalties from VisiCalc. By 1983, however, more powerful programs such as the Lotus 1-2-3 had been released and outsold the outdated VisiCalc, which never regained its early industry position.
The personal computer revolutionized office spaces in the 1980s, and VisiCalc was the first application to firmly establish the need for the PC in the business environment. The importance of a spreadsheet application for businesses today is without question, and VisiCalc pioneered the spreadsheet technology that can still be seen in programs such as Microsoft Excel, Apple Numbers, and Google Sheets.

Chapter 6
Write up on tech geek HISTORY: Integrated Data Store (IDS) General Electric
Background of the Study:
Introduction:
Charles Bachman was a pioneer in the management of computer database systems. He spent his entire career in industry, working for Dow Chemical, GE, Honeywell, Cullinane Database Systems, and his own startup Bachman Information Systems. His work at GE in the early 1960’s, building the first company-wide database management system, called Integrated Data Store (IDS), allowed users across the company to access a common database. In 1973 he was awarded the ACM Turing Award for this work
Bachman created IDS as a practical tool, not an academic research project. In 1963 there was no database research community.
Literature Review:
One of the oldest DBMSs, Integrated Data Store (IDS), was developed at General Electric by Charles Bachman during the early 1960s using the network model. The Conference on Data Systems Languages (CODASYL), an organization consisting of representatives of major hardware and software vendors and users, was formed to try to standardize many aspects of data processing. CODASYL had successfully written standards for the COBOL language. In the late 1960s the CODASYL organization formed a subgroup called the Data Base Task Group (DBTG) to address the question of standardization for database management systems. Influenced by IDS, the group proposed a network-based model and specifications for data definition and data manipulation languages. In 1971 its first official report was submitted to the American National Standards Institute (ANSI), which refused to accept or reject the proposed standard. The 1971 report was succeeded by several newer versions, but it remained the principal document describing a network-based model generally referred to as the CODASYL model or the DBTG model, and several popular database management systems were based on it. In addition, it provided the vocabulary and framework for discussion of database issues, establishing for the first time the notion of a layered database architecture and common terminology. Although the hierarchical and network models were powerful and efficient, they were complex, requiring users to understand data structures and access paths to data. They were designed for use with programs rather than for interactive access by users. The logic required to locate the desired records was contained in the applications, not in the database The relational model was first proposed by E.F. Codd in 1970, in a paper called “A Relational Model of Data for Large Shared Data Banks.” It was the first model based on abstract concepts from mathematics, which provided a strong theoretical base. Early research on the model was done at the IBM Research Laboratory in San Jose, California. System R, a prototype relational database management system (RDBMS), was developed by IBM researchers during the late 1970s, and the research results, including the development of a new language, SQL (Structured Query
1.1
Historical Developments in Information Systems 13 Language), were widely published. Another important research project based on the relational model was Ingres, developed at the University of California, Berkeley, by Eugene Wong and Michael Stonebraker. Both Postgres and PostgreSQL were developed from Ingres. Recognizing the value of the relational model, Larry Ellison, along with Bob Miner and Ed Oates, founded a company to use the results of the System R project and released Oracle, the first commercial RDBMS, in 1979. IBM released its first commercial RDBMS, called SQL/DS, in 1981, followed by the announcement of DB2 in 1983. The widespread use of microcomputers beginning in the 1980s led to the development of PC-based RDBMSs. SQL, the language developed for System R, became the standard data language for relational-model databases, with ANSI-approved standards published starting in 1986, major revisions in 1992 (SQL2) and 1999 (SQL3), and further expansions in 2003, 2006, 2008, 2011, 2016, and 2019. Oracle, DB2, Microsoft’s SQL Server, MySQL, Microsoft Access, and PostgreSQL, all of which use the relational model, are popular DBMSs. The relational model uses simple tables to organize data. However, it does not allow database designers to express some important distinctions when they model an enterprise. In 1976, Peter Chen developed a new type of model, the entity-relationship (ER) model. This is an example of a semantic model, one that attempts to capture the meaning of the data it represents. It is most often used in the design phase for databases. The ER model has been extended several times to make it semantically richer, resulting in the extended entity-relationship (EER) model
1.2
Before integrated databases were created, file processing systems were used, and data used by an organization’s application programs was stored in separate files. (Note: Although the word data is plural in standard English, it is customary to use it as both singular and plural in database literature, as in “data is” and “data are.”) Typically, a department that needed an application program worked with the organization’s data processing department to create specifications for both the program and the data needed for it. Often the same data was collected and stored independently by several departments within an organization, but not shared. Each application had its own data files that were created specifically for the application and that belonged to the department for which the application was written. Personal computer databases can create a similar scenario, where individuals or departments set up their own databases or spreadsheets containing data, creating data silos, isolated collections of data that are inaccessible to other departments within an organization. Having multiple copies of the same data within isolated files or small databases can lead to flawed, outdated, or contradictory information, thus creating confusion for users. Most organizations can benefit by having the data used for sets of applications integrated into a single database. In this text, we assume the typical database is a large one belonging to a business or organization, which we will call the enterprise. However, the techniques described apply to databases of all sizes. An integrated database is a collection of related data that can be used simultaneously by many departments and users in an enterprise. It is typically a large database that contains all the data needed by an enterprise for a specific group of applications or even for all of its applications stored together, with as little repetition as possible. Several different types of records may appear in the database. Information about the structure of the records and the logical connections between the data items and records is also stored in the database, so that the system knows, for example, which faculty record is connected to a particular class record. This “data about data” is called metadata.
1.3
The Integrated Data Store (IDS), the first direct-access database management system, was developed at General Electric in the early 1960s. Revisiting the development challenges that lead to its first production version reveals the origins of DBMSs and their impact on software development and business management. IDS and its derivative systems are still in use today, supporting a thousand mainframe installations
1.4
In the late 1950s and early 1960s, no independent software vendor industry existed. Software of all kinds was developed either by computer manufacturers or by one or a group of computer users. It was either bundled with the computer at no extra cost or given away free and shared by the users who developed it, much like today’s open source movement. This article will examine the business requirements that lead to the development of the Integrated Data Store (IDS), the first direct-access database management system (DBMS),1 and will look at some of the develop[1]ment challenges that lead to its first produc[1]tion version. To this day, IDS leads a healthy, productive life, driving large transaction[1]oriented systems around the world, 50 years after its conception. When General Electric engineers first began developing IDS in 1961, there were no general purpose operating systems, no file systems, no DBMSs, and no communications systems to learn from or build on. There was no multi[1]programming, time sharing, or online debug[1]ging tools. The machines were essentially naked. For business data processing, it was a batch-oriented, serial-file-processing, load and execute one-program-at-a-time world
1.5
DEFINITION STRUCTURE The Definition Structure required by IDS is a list structure which reflects the description of the various data records of the IDS file. It defines the master/detail relationships between data records, the chain characteristics, and the physical and control characteristics of every field of every record type in the IDS file.
In the late 1950s, GE was the largest commercial user of computers in the world. GE was also the biggest manufacturer of computers for demand deposit accounting. From 1958 to 1965, the GE Integrated System Projects (ISPs) were driven by GE’s Manufacturing Services, lead by Halbert Miller. The company’s corporate services provided research, expertise, and consulting to its 100 product manufacturing departments. These product departments were in a range of product areas: atomic energy, electric energy generation and distribution, jet engines, electric motors, home appliances, light bulbs, x-ray machines, diesel electric locomotives, artificial diamonds, and general-purpose computers. At that time, GE’s Manufacturing Services management was greatly concerned that all of GE’s manufacturing businesses were investing heavily in the design and installation of computerized manufacturing systems and that the development process was slow, expensive, and error prone.
The first ISP (1958–1959) developed some interesting product ideas in the area of manufacturing simulation (later leading to SIMSCRIPT), generative engineering, and decision tables (TABSOL).
The second ISP (ISP 2) began late in 1960. Its target was to design and build a generic manufacturing control system. The project was managed by GE’s Production Control Ser[1]vice and lead by Stanley B. Williams. Williams came from the GE Large Transformer Department in Pittsfield, Massachusetts, and had 12 years of engineering and engineering systems experience. I joined the project as its chief architect, with 10 years of experience in engineering, finance, manufacturing, and data processing with the Dow Chemical Company in Midland, Michigan
The first packaged versions of IDS did lack some features later viewed as essential for database management systems. One was the idea that specific users could be granted or denied access to particular parts of the data[1]base. This omission was related to another limitation: IDS databases could be queried or modified only by writing and executing programs in which IDS calls were included. There was no capability to specify “ad hoc” reports or run one-off queries without having to write a program.
These capabilities did exist during the 1960s in report genera[1]tor systems (such as 9PAC and MARK IV) and in online interactive data management systems (such as TDMS) but these packages were generally seen as a separate class of software from database management systems. By the 1970s report generation packages, still widely used, included optional mod[1]ules to interface with data stored in database management systems.
Integrated Data Store (IDS) The IDS DBMS was created by assembling many elements that had appeared in research papers and existing systems. We combined these with some new elements so that the whole would meet the envisioned manufacturing control system’s requirements. This included the following elements: A direct access database was implemented on a virtual memory basis, with page turning, revitalized hash (calculated) addressing, data integrity control, clustered records, and database keys. The network data model, with logical records that mapped transparently onto physical records in the virtual memory and logical O/M sets, was mapped transparently onto linked lists of physical records.
A data description language, with Data Description Language (DDL) statements that defined the types of logical records with their data, relationships, and constraints that could appear within the database. A data storage and retrieval language, with Data Manipulation Language (DML) statements could be easily integrated into a record-at-a-time procedural language, such as GECOM, Comtran, Fact, Cobol, or PL/1, which were also available. The record-at-a-time data-manipulation statements included STORE, RETRIEVE, MODIFY, and DELETE. An exclusive ‘‘working storage’’ area for each record type, providing the computer memory locations where IDS and the application programs, could exchange data under tight integrity controls.

Chapter 7
Write up on Tech Geek History: FORTRAN Complier
Literature Review
FORTRAN as a Programming Language
The FORTRAN programming language was conceived in the early 1950s the name produced from the two words Formula Translation. In 1966 the language was standardized and FORTRAN IV was born.
Revision of the language led to FORTRAN 77, the language we use today. The standard for FORTRAN 90 is now available although not yet in widespread use. F77 is a subset of F90.
FORTRAN was designed for scientists and engineers, and has dominated this field. For the past 30 years FORTRAN has been used for such projects as the design of bridges and aero plane structures, it is used for factory automation control, for storm drainage design, analysis of scientific data and so on.
The Fortran Programming Language
Fortran is a programming language with a long history. Originally developed in the 1950s, it was first created in a time before the internet, laptop computers, and desktop computers before computers even have a screen. Fortran was created at a time when computers were almost exclusively designed and operated to carry out numerical operations. Programming in Fortran today is very different from how programmers introduce instructions and compile codes. During the first decades of electronic computers, programming was done with punched cards, data was stored in tapes, and results were printed with dot matrix printers. Over more than 60 years, the language itself has evolved to accommodate new ways of programming, new hardware, new levels of complexity, and new ways of using computers for numerical calculations.
Evolution of Fortran
The first versions of the language introduce many of the concepts used today in most programming languages, the idea of loops, conditionals, and variables. Those elements are so commonplace today that we do not see as anything revolutionary, but FORTRAN was the first language to introduce many of those elements in programming, at least in a way that resemble the ways we program today.
The first milestone in the language was achieved with FORTRAN 77. This standard introduces structured programming and the processing of characters. Structured programming allows us to create larger codes and reuse pieces of code in ways that are easier to understand for a human. FORTRAN 77 was so successful that took more than a decade to reach an agreement over the new milestone. Fortran 90 added array, modular and generic programming. Those elements increase the flexibility of codes to accommodate data in run time instead of requiring constant recompilation when the parameters changed. Modules allow even larger codes to introduce tools to aggregate routines with variables. Fortran 90 left behind some issues that were solved in Fortran 95. Fortran 95 clarify some aspects of the language and was the first to introduce some parallelization techniques (HPF) well before OpenMP and other paradigms proved to be more effective for that. Fortran 2003 was the next big step in introducing Object Oriented Programming in a way that makes sense for scientific computing. The most recent developments in the language come from Fortran 2008 and 2018 which includes native parallel computing in the form of Co-arrays.
With such extensive evolution of the language, the standard retained compatibility with previous versions, being far more conservative than other languages. Scientific codes are developed for decades and used even longer. Many of the codes that run today on larger supercomputers were first developed in the 1980s and could have 1 million lines of code or more. If the language specification does not retain some compatibility many of those efforts could be lost or will become attached to older compilers losing the ability to evolve themselves.
.In this Paper is discussed the Earlier Version of Fotran; the History of:
Focusing on Fotran Compliers what Fotran is most distinctive
The IBM 1401 FORTRAN compiler1 was designed as a set of phases that operate sequentially on the source program. The source program having been placed in core storage, the compiler phases enter core one at a time. Each phase overlays its predecessor, operates on the source program and, in turn, is overlaid by the next phase of the sequence. Thus, in contrast to the customary technique of passing the source program against the compiler in core, the compiler is passed against the source program which resides in core. It is assumed that the source program is more concise than the object program, and that an object program of interest can be accommodated in core.
The 1401 FORTRAN compiler was designed for a minimum of 8000 positions of core, with tape usage being optional. The fundamental design problem stems from the core storage limitation. Because the average number of instructions per phase and the number of phases selected are inversely related (at least to a significant degree), the phase organization was employed to circumvent the core limitation. The 1401 FORTRAN compiler has 63 phases, an average of 150 instructions per phase, and a maximum of 300 instructions in any phase.

efficiency of the compilation technique Experience with the compiler suggests that, even though the basic compilation technique requires repetitive scanning of the source program, the time required for this redundant effort is small. The experience lends some credence to the following argument.
If a phase is decomposed into two serially acting phases, assume that the average execution time is increased by a multiplicative factor r. If each component phase is again decomposed into two phases, the average total execution time of the resulting four phases increases to r2 times the original. After k decompositions, 2k phases result, with an average total execution time of rk times the original. Under this assumption, it follows that an n-phase compiler takes rlog2n times longer than a comparable one-phase compiler. Because some phases do not involve scanning, this estimate may tend to be high.
Based on experience with the present compiler, it is conjectured that r ~ 1.05 and that the redundant work occasioned by the use of 63 phases increases compilation time by a factor of 1.05log263 ~ 1.3.
However, this technique reduces compilation time elsewhere, so that the net increase can be expected to be less than conjectured. Since the phases act serially, tape searching is unnecessary. Moreover, no external sorts or merges are required. After one pass of the processor, the object program lies in core storage, ready for execution.
Also, the present technique permits an approach to coding that tends to reduce compilation time. Decomposition into an appropriate number of phases often results in more available core space for execution of an individual phase than the minimum needed.
The typical phase requires only on the order of 150 instructions, although twice that number are accommodated by the allocated region in core. Thus, most of the code can be written for efficient execution without regard to economy in the number of instructions employed. Other advantages inherent in this type of coding are that it is usually faster to write and easier to debug.
________________________________________compilation time Except for certain extreme cases in which the object program fills almost all of core, the compilation time in seconds t is approximated by a linear function of the number of FORTRAN statements n (the statements assumed to be of average complexity). If the compiler is on tape, reads the source program from cards, and punches a self-loading machine language object program, then t = (0.96n + 72) seconds. As a load-and-go system, with the punching of the object program suppressed, t = (0.76n + 22) seconds. If the system is on cards, an additional 173 seconds are required.
________________________________________compiler phases The principal function of each phase of the compiler2 is indicated below. Secondary functions are subordinated; for ex- ample, error checking occurs in almost every phase, but is seldom mentioned.
Phase 00 – Snapshot. Loads a snapshot routine into 350 positions of core storage. This routine lists a specified amount of core storage.
Phase 01 – System Monitor. Brings in the next phase from the system tape or initiates reading of the next phase from cards, depending on whether the compiler is used as a tape or card system. The monitor and snapshot routines are the only ones that exist in storage throughout compilation. Because the phases act serially, very little is required of this phase which consists of only 20 instructions.
Phase 02 – Loader. Stores the entire source program, statement by statement, with all non-significant blanks eliminated. The source program is stored backwards in order to use the 1401 machine instructions that cause address registers to decrement when processing data. Appended on the right of each statement is a three-position internal sequence number (001 for the first statement, 002 for the second, etc.). The sequenced source program is printed.
Phase 03 – Scanner. Determines the type of each statement and appends a code on the right of each statement. For example, D for DO, S for STOP, I for DIMENSION statements, etc.
Phase 04 – Sort I. Determines if there is enough free storage to expand each statement by three characters.
Phase 05 – Sort II. Statements of the same type are chained together. Each statement expands by three characters-the machine address of the next statement of the same type.
Phase 06 – Sort III. The source program is sorted3 internally by statement type. The order of sorting is determined by the order in which statements of a given type undergo specific processing by subsequent phases. For example, since DIMENSION statements are processed (Phase 09) before DO statements (Phase 46), the DIMENSION statements are grouped together lower in core than the DO statements.
Phase 07 – Insert Group Mark. This is a housekeeping phase.
Phase 08 – Squoze. The words that helped define the type of each statement are eliminated, shrinking the source program. For example, the word “DIMENSION” in DIMENSION statements is eliminated.
Phase 09 – Dimension I. The DIMENSION statements are scanned, and an array table is generated in free storage. Each table element consists of the name of an array, its dimensions, and sufficient space for additional data to be. generated by Phases 11 and 12.
Phase 10 – Equivalence I. Adds simple variables present in EQUIVALENCE statements to the array table. These variables are treated, in effect, as one-element arrays.
Phase 11 – Equivalence II. The array table is altered to show the relationship between arrays. Equated arrays are chained together. Essentially, the procedure makes known to every array whose first element is equivalent to a secondary element of another array the “distance” to the first element of the latter array.
Phase 12 – Dimension II. The object-time addresses which delimit each array are computed and inserted in the array table. These addresses are also printed.
Phase 13 – Variables I. The entire source program is scanned for variables. The following changes are made directly within the text of the source program:
Simple variables are tagged for later processing by Phase 16.
Subscripted variables with constant subscripts are replaced by the object-time address of the designated array element.
All other subscripted variables are put into a canonical form which specifies a computation in terms of variables and constants for determining the object-time address of the array element specified.
Non-subscripted array names appearing in lists are replaced by the object-time address that delimit the array named.
Non-subscripted array names appearing elsewhere are replaced by the object-time address of the first element of the array.
Phase 14 – Variables II. All free storage (including the array table) is cleared and partitioned into two tables areas-Tables I and II. Parameters needed for the randomizer of Phase 16 are computed.
Phase 15 – Variables III. Does housekeeping for Phase 16.
Phase 16 – Variables IV. The source program is scanned twice for simple variables (already tagged by Phase 13). During the first scan, the compiler looks for variables being defined, i.e., those appearing on the left of an equal sign or in input lists. By means of a randomizer that computes an indirect address (a Table I address at which is located a Table II address), each such variable and its object-time address is stored uniquely and sequentially (one after another) in Table II. The object-time address replaces the variable name in the source program. During the second scan, all other variables are picked up, and the same process is carried out, except that undefined variables are noted and Table II entries are flagged whenever referenced.
Phase 17 – Variables V. Table II is scanned. The absence of a flag indicates an unreferenced variable. The object-time address of each variable is printed.
Phase 18 – Constants I. The entire source program is scanned for constants. Each constant encountered is normalized and tagged. Tables I and II are destroyed.
Phase 19 – Constants II. All free storage is again cleared and partitioned into two table areas- Tables I and II. Parameters are now stored, each with its identifier (Phase 32), in lower core immediately to the left of the list and format “statements.”
Phase 20 – Constants III. The entire source program is scanned for normalized constants (tagged by Phase 18). By means of a randomizer (as in Phase 16), each normalized constant is stored uniquely and sequentially (next to one another) in Table II. Once stored, these constants are at their object-time address and are not disturbed for the remainder of the compilation. The object-time address replaces the normalized constant directly in the text of the source program.
Phase 21 – Subscripts. Under the action of Phases 14 through 20, the canonical form for subscripted variables (see Phase 13) now specifies a computation in terms of object-time addresses. This phase simplifies the computation, leaving only the object-time addresses which serve as parameters for a closed subroutine at object time.
Phase 22 – Statement Numbers I. Statement numbers that appear in the source program are reduced to a 3-character representation. Statement numbers within the body of a statement are moved to the front of the statement.
Phase 23 – Format I. FORMAT statements are checked to ensure that they are referenced by input/output statements.
Phase 24 – Format II. The object-time format strings are developed and stored immediately preceding the constants at the lower end of storage.
Phase 25 – Lists I. Duplicate lists are checked and eliminated to optimize storage at object time.
Phase 26 – Lists II. The object-time list strings are developed and stored immediately to the left of the format strings at the lower end of storage.
Phase 27 – Lists III. Each input/output statement is reduced to the address of the list string (when present), the address of the format string (when present), and the tape unit number (where applicable).
Phase 28 – Statement Numbers II. All free storage is again cleared and partitioned into two tables-Tables I and II. Parameters needed for Phase 29 are computed.
Phase 29 – Statement Numbers III. By means of a randomizer (as in Phase 16), statement number representations (Phase 22) appearing within statements are stored uniquely, one after another, in Table II. Each such representation is replaced by the machine address at which it is stored.
Phase 30 – Statement Numbers IV. Statement number representations are matched against Table II entries via the randomizer of Phase 29. The sequence number of the statement (Phase 02) replaces the Table II entry. The Table II address (which now contains the sequence number) replaces both the representation and the sequence number in the source program. Undefined and multiply-defined statement numbers are checked.
Phase 31 – Statement Numbers V. Table II is scanned for unreferenced statement numbers (representations).
Note: Whereas the source program originally was composed of constants, variables, and statement numbers of arbitrary length, it is now highly structured and is composed of 3-character machine addresses. Machine addresses substituted for constants and variables are their object-time addresses. Machine addresses substituted for statement numbers are indirect addresses which currently reference Table II entries-sequence numbers of labeled statements. Eventually (Phase 51) these indirect addresses are replaced by the object-time addresses of the labeled statements, i.e., the addresses of object programs compiled from these statements.
Phase 32 – Input/Output I. The residue of each I/O statement other than BACKSPACE, REWIND, and END FILE is substituted into an object-time mask. The filled-in mask and an identifier are stored in lower core immediately adjacent to the last entry in Table II. The identifier is the sequence number (Phase 02) or, only when the statement originally had a statement number, the machine address of the sequence number stored in Table II (Phase 30).
Phase 33 – Arith I. All arithmetic expressions appearing in the source program are scanned. Switches are set to indicate which function routines must be loaded by Phase 52. Minor changes are made to expressions, and sufficient error testing is done to expedite Phase 34.
Phase 34 – Arith II. By means of a transition matrix,4 each arithmetic expression is broken down into a sequence of one or two operand sub-expressions involving temporary dummy storage locations.
Phase 35 – Arith III. Initialization for Phase 36.
Phase 36 – Arith IV. Redundant references to temporary dummy storage locations are eliminated by forming maximal strings of operands and operators from each sequence of sub-expressions. Each string specifies the computation in which (1) unary operators act on the entire substring immediately to their left and (2) binary operators combine this substring with the operand on their right.
Phase 37 – Arith V. Exponentiation operators are replaced by substrings involving log and anti-log functions. Implied mode changes are made explicit by inserting (or deleting) fix or float operators in the strings. The Table II addresses (Phase 29) appearing within IF statements (involving arithmetic expressions) are substituted into masks of object-time instructions. The filled-in mask replaces the addresses in the source program.
Phase 38 – Arith VI. The arithmetic strings are altered so that temporary storage areas are shared whenever possible. Machine addresses are determined for these areas and substituted for the dummy addresses in the strings. Previous arithmetic and IF statements are now stored, each with its identifier (Phase 32), in lower core immediately to the left of the list and format “statements.”
Phase 39 – End file, Rewind, Backspace.
Phase 40 – Computed Go To.
Phase 41 – Go To.
Phase 42 – Stop/Pause.
Phase 43 – Sense Light.
Phase 44 – If (Hardware).
Phases 39 through 44 are essentially the same. In each phase, the residue of statements of the indicated type are substituted into masks of in-line, object-time instructions. The filled-in masks are stored with their identifiers (Phase 32) at the next available locations in lower core.
Phase 45 – Continue. No object-time instructions are generated for these statements. Only the identifiers (Phase 30) are stored in lower core.
Phase 46 – Do. DO statements are analyzed for nesting. Illegal nesting is noted. The residue of each DO statement is substituted into an object-time mask; but in general, the exit address is left blank. The partially filled-in mask and its identifier are stored in lower core. An unconditional branch is generated (uniquely) to follow (via Phase 49) the last statement within the range of the DO.
Note: At thus point, the entire source program has been transformed into (essentially) object program procedure. For simplicity, we continue to write “statement” when we mean “procedure compiled from statement.”
Phase 47 – Resort I. An area is made available for a table to assist in resorting the statements into their original order.
Phase 48 – Resort II. The resort table is filled with the current location of each statement.
Phase 49 – Resort III. The statements are resorted back into their original order with the identifiers eliminated. The Table II entries (sequence numbers of statements originally labeled with statement numbers) are replaced by the current machine ad- dresses of those statements. Exit addresses are substituted into the procedure generated for DO statements (Phase 46). For each executable statement, the sequence number and the object-time starting address of the generated procedure are printed.
Phase 50 – Resort IV. The statements are shifted to the places they will occupy at object time. The Table II entries are bumped accordingly.
Phase 51 – Replace I. The entire object program procedure is scanned for indirect addresses (see note following Phase 31). Each indirect address is replaced by its direct address-now available in Table II.
Phase 52 – Function/Subroutine Loader. Relocatable function routines and subroutines (which comprise Phase 53) are selectively loaded. A table of starting addresses of these routines is created in free storage.
Phase 53 – Relocatable Package. This phase consists of the relocatable routines loaded by Phase 52.
Phase 54 – Format Loader. The object-time format routine, which is included in this phase, is loaded.
Phase 55 – Replace II. Those instructions in the generated object program that should branch to the relocatable routines are modified (via the table of Phase 52) to show the object-time addresses of these routines.
Phase 56 – Snapshot. A snapshot of the generated program is printed if initially requested and if no source program errors have been detected that would make program execution unrewarding.
Phases 57, 58, 59, 60 – Condensed Deck. When requested and if there are no input errors, these phases punch and list the object program as a self-loading condensed card deck.
Phase 61 — Geaux I. This phase prints the end-of-compilation message, initializes the sense lights, and prepares the branch into the object program coding.
Phase 62 – Geaux II. The arithmetic routine (Phase 63) is read into storage. Communication between this routine and the relocatable routines is established. The object program is executed on option.
Phase 63 – Arithmetic Package. This phase consists of the arithmetic routine loaded by Phase 62.
The First IBM Fotran Compiler is discussed on a more Technical -High End Scale Point:
The IBM FORTRAN Pre-Compiler is a program that detects and permits correction of errors in a FORTRAN source program before the object program is compiled. The Pre-Compiler detects many of the more common programming errors in individual source statements, and indicates possible logical errors in the source program as a whole. Two versions of the Pre-Compiler are provided, one for use with the IBM 1621 Paper Tape Reader and IBM Tape Punch, and the other for the IBM 1622 Card Read Punch.
A FORTRAN source program which is to be processed was to be punched in paper tape or cards, or may be entered directly from the typewriter.
The operation of the Pre-Compiler could be divided into two phases: Error Analysis and Final Program Summary. During the error analysis phase, each statement in the FORTRAN program is analyzed for an error. If an error is detected, an error code is typed, the statement containing the error is typed, and the program halts so that you can type the statement correctly.
During this phase, a new FORTRAN source program was punched in paper tape or cards. After all statements have been analyzed and corrected, if desired, a final program summary is typed. The final program summary phase includes information about possible sources of errors not detectable in individual source statements. An additional feature of the Pre-Compiler program, using the 1620 program switches, permits you to easily alter the functions of the error analysis phase for individual requirements. The following options are available.
The following were Instructional Sets based on the Original Fotran Complier:

1. You can suspend the halt and error correction routines, thereby providing a quick error analysis only. These routines can be suspended for the entire program or for individual error halts during normal processing.
2. You can enter the program through the console typewriter rather than by card or paper tape input.
3. You can eliminate punching of an edited source program.
4. You can have correct program statements typed, in addition to the normal operation in which only incorrect statements are typed. The standard 1620 FORTRAN Pre-Compiler system contains all of the functional subroutine names included in the standard FORTRAN system. If you make alterations to the functional names, or if you add additional subroutines to the FORTRAN system, you must make the corresponding alterations and additions to the PreCompiler system.
   Operation of the Pre-Compiler Program Error Codes 72 Before you process any program on the Pre-Compiler, you should be familiar with the nature of the errors that the program is deSigned to detect.
   During the error analysis phase of the program, each statement is analyzed for one or more specific errors. These errors consist of 51 of the most common errors usually found in FORTRAN source programs.
   As an aid in evaluating these errors, they have been grouped into seven categories: Arithmetic statements Arithmetic Statements Variables in Arithmetic
   Expressions DO Loops Constants Variables in arithmetic statements DO loops Constants Statement numbers Transfer statements General
   When an error is detected, an error code is typed on the console typewriter. This code consists of an alphabetic abbreviation of one of the categories listed above, followed by a number that designates the particular error in the category. ARITH
5. Unacceptable form to left of == sign.
6. Multiple == signs.
7. This code has been deleted.
8. Successive operation symbols, or a function which is followed by an operation symbol. 5. Missing operation symbol or operand.
9. Right parenthesis encountered before corresponding left parenthesis.
10. Missing right parenthesis.
11. Mixed mode expression (expression contains fixed and floating point).
12. No variable to the left of equal sign.
13. Involution of a fixed point variable or constant. VAR
14. Variable name longer than 5 alphameric characters.
15. Variable appearing in an expression or as a subscript not previously defined in an input statement; as the index of a DO loop; or defined as the left side of another arithmetic statement.
16. Variable written with a subscript has not been previously defined in a DIMENSION statement.
17. Variable previously defined in a DIMENSION statement has not been subscripted correctly: subscript is in unacceptable form, number of subscripts does not agree with the number specified in DIMENSION statement, numerical subscript is greater than maximum allowed by DIMENSION statement or is less than
18. DO 1. In the statement DO n i == m], m 2 , m,J, the indices m}, m 2 , and m.l , if given, are not all unsigned fixed point variables or constants greater than zero. There are more than 3 indices given.
19. The second index, m2 , is less than mJ, when botq are constants.
20. The third index, m.l , is signed, is zero, or is missing when specified as a constant.
21. The statement number n is not in acceptable form or is missing.
22. The variable name has either been omitted, or is incorrectly stated, or the DO statement is incorrect.
23. The statement specified as the end of an outer loop in a nest of DO’S has been found before an inner loop is complete.
24. A DO loop terminates with a transfer statement, GO TO, computed GO TO, or
    IF. CONST
25. Fixed point constant longer than 4 digits.
26. Floating point constant outside the allowable range.
27. Decimal point omitted from floating point constant that is written with a decimal exponent.
    The FORTRAN Pre-Compiler Program
    73 Statement Numbers Transfer Statements General
    74
28. The decimal exponent following the E in a floating point constant is incorrectly expressed in form or size.
29. The exponent following an E has been omitted.
30. Floating point number followed by an alphabetic character other than E.
    STNO
31. Statement number longer than 4 digits.
32. Statement number has been previously defined.
33. Unnumbered CONTINUE statement. (Should be numbered when used as last statement in a DO loop.)
34. Statement immediately following a transfer statement is not numbered, and is therefore inaccessible to the source program. (If the previous statement is a transfer, the only way the program can process this statement is by a transfer to it, and therefore it must always be numbered.)
    TRANS 1. Statement numbers in a transfer statement (GO TO, computed GO TO, or IF) are not acceptable fixed point numbers; there is no comma between statement numbers, or there is not the required number of statement numbers. 2. 3. 4. 5. 6. 1. 2. 3. 4. 5. 6. Comma missing after the right parenthesis in a computed GO TO statement. Index in a computed GO TO statement is not a fixed point variable, or is missing. Nonnumerical character follows right parenthesis in an IF statement. In an IF statement, a character other than a left parenthesis follows the word IF. No arithmetic statement within the parentheses after the IF. (However, empty parentheses in an arithmetic statement will not be detected.)
    GEN Misspelled or unacceptable nonarithmetic statement. Statement contains an unacceptable character. More than 72 characters in statement (not applicable to cards). Symbol table full (occupies more than 2,500 digits in storage). Statement contains decimal point that is not in a floating point constant. Input/output statement contains no FORMAT number, or is incorrectly stated.
35. First character in an input/ouput list is not alphabetic, or the final character is not a letter or a digit.
36. In a DIMENSION statement, a nonalphabetic character precedes the first variable name or a dimension, or three dimensions have been specified ( only two-dimensional arrays are permitted).
37. A specified dimension is incorrect: a parenthesis has been omitted, a floating point constant or an unacceptable fixed point constant has been used, etc.
38. Unnumbered FORMAT statement.
39. Incomplete FORMAT statement: invalid or incorrect specification, missing parentheses, character after right parenthesis, etc.
40. In an input/output statement, comma is missing after the FORMAT statement number, or the list is missing or invalid.
41. The total record width specified in a FORMAT statement exceeds 87.
42. A variable in a DIMENSION statement has been previously defined.
43. a. The letter H orX is missingin an alphameric FORMAT statement or the width of an alphameric FORMAT statement is greater than
44. b. A FORMAT statement does not contain any of the specification types, I, H, X, E, or F. Error Analysis Phase Restart Procedure Final Program Summary After an error has been detected in a statement, and the appropriate error code has been typed, the original error statement is typed. If switch 3 is off, the carriage is returned and the program halts to wait for a corrected statement to be typed in. After reviewing the erroneous statement and the error code or codes indicated, you can, in most cases, make an immediate correction to the statement. Type the correct statement (followed by a record mark), then press the release and. start keys.
    The program resumes by analyzing the statement just typed to determine if any errors still exist. If the statement is correct, the program will begin analyzing the next statement in the FORTRAN program. In some cases, it may not be possible to re-enter a corrected statement without certain modifications because part of the statement has already been processed as a correct statement. For example, if an error is discovered in a transfer statement (GO TO), you must enter the correct statement with a statement number to avoid error STNO 4, or enter it twice without a statement number. (The program considers the first part of the GO TO to be correct, and requires that any statement following a transfer statement must contain a statement number). When a statement containing a statement number is partially processed due to an error, you cannot re-enter the statement with the statement number because an error STNO 2 will result. In an erroneous DIMENSION statement, for example DIMENSION C ( N ), the C is stored as a nonsubscripted variable and cannot be used later in the program as a subscripted variable. In case of C( 10,N), the C is stored as a one-dimensioned variable. Restart of the Pre-Compiler is necessary.
    For expressions involving involution (raising to a power), the exponent cannot have an involution operation. For example, A * * (B * * 2. +.1) will result in erroneous operation of the Pre-Compiler. This restriction also applies to the arithmetic expression in an IF statement. There is no check for the termination of a DO loop.
    If a dimension specification exceeds the capacity of the storage, erroneous results will follow. If an immediate correction cannot be made, you can resume testing of the next statement by manually branching to BEGIN (see RESTART PROCEDURES). It is important to note that if a new source program is being punched, bypassing the error correction routine will result in the incorrect statement being punched into the output tape or cards.
    The normal operation of the Pre-Compiler program is to type incorrect statements only. If you require a typed copy of all statements, turn on program switch
45. You may find it necessary during processing to interrupt the normal operation of the program. To allow such interruptions, the following re-entry points, given by symbolic label and storage location, are available: CLEAR location 01208: The symbol table and table of statement numbers referenced by DO statements are cleared. CLEAR is the restart point for a new program to be tested. INITL location 01340: The table of statement numbers referenced by DO statements is cleared
46. . BEGIN location 01472: No tables are cleared, but the program will continue to read source program statements. BEGIN is the normal entry point for restarting after a check stop or other interruptions of the Pre-Compiler. After the END statement in a source program has been processed by the PreCompiler program, a final program summary was a typewritter
    ENTER SOURCE PROGRAM THEN PUSH START and the program will halt. Set the console program switches for the correct input I output options, mount the source tape or load the source deck, and begin processing by pressing the start key. After the END statement in a source program has been processed, the final program summary will be typed on the console typewriter. This will consist of the following four messages, together with the related lists of statement numbers and relocatable subroutines called by name in the source program.
    UNDEFINED STATEMENT NUMBERS UNREFERENCED STATEMENT NUMBERS RELOCATABLE SUBROUTINES CALLED OBJECT PROGRAM DATA TABLE XXXXX STORAGE POSITIONS
    The absence of one of the first three messages indicates that no undefined or unreferenced statement numbers have been found, or that no relocatable subroutines have been used by name in the source program. Undefined statement numbers are those referenced by a transfer, DO or Ilo statement, but not defined. After the final summary has been typed, the following message will be typed on the console typewriter and the program will halt.
    PROCESSING COMPLETE Pressing the start key causes the program to clear the symbol table compiled during the processing of the previous source program and to prepare to process a new program. When this has been done, the program will type the message which calls for the entry of the source program.
    The 1620 FORTRAN Pre-Compiler program deck was made up of four sections, identifiable by sequence number as follows: 00000-00001 Loading routine 00002-00361 Pre-Compiler program 00362-00367 Arithmetic tables 02001-02007 Relocatable subroutine data The relocatable subroutine data consists of a card containing the number of relocatable subroutines included in the program deck, and the following cards contain the names of these subroutines. These cards must be in the proper sequence.
    If they are out of sequence, an error message will be typed and the 1620 will halt. Restore the sequence of these cards (including the two cards from the reader stacker), press the reader start and start keys to continue the operation. General Make-up of Program Tape Tape Data Duplicating the Pre-Compiler Tape The relocatable subroutine cards are punched with the function name starting in column 1 and the sequence number in columns 76 through 80. Subroutine names added to the system must be punched in the same manner.
    The 1620 FORTRAN Pre-Compiler tape consisted of a loading routine which loads the multiply and add tables, and the program which follows. The last seven records are the relocatable subroutine data containing the number and names of the relocatable subroutines included in the program. These records must be exact duplicates of the corresponding records which are included in the 1620 FORTRAN processor tape. Additions to the list of relocatable subroutines in the system must be made to the Pre-Compiler tape in exactly the same form as prescribed for the 1620 FORTRAN processor tape. For the purpose of tape identification, a title and data message have been incorporated in the 1620 FORTRAN Pre-Compiler tape. The first two records of the tape contain the title and data information. After these records have been read into the 1620, the following message will be typed: 1620 FORTRAN PRECOMPILER 11/15/61 Normal processing continues after the message has been typed.
    The FORTRAN Pre-Compiler tape was duplicated and/or modified by the use of the program for duplicating the FORTRAN processor and subroutine tapes, in the manner described for duplicating the processor tape.
    References::
    http://www.bitsavers.org/pdf/ibm/1620/C26-5619-4_1620_Fortran_Mar64.pdf
    https://ibm-1401.info/1401-IBM-Systems-Journal-FORTRAN.html

The post Write up on Tech Geek History Chapter 1 to 7 book form appeared first on DayDreamin’ Comics.

Doctor Who A Cave of Skulls originally aired November 30, 1963
When last we left Doctor Who, concerned teachers Ian (William Russell) and Barbara (Jacqueline Hill) barely had time to process the claims that their gifted student Susan (Carole Ann Ford) and her “grandfather” the Doctor (William Hartnell) were time-traveling aliens before the old man threw some switches and shanghaied them off into the time stream.
After a bumpy ride (by early Doctor Who standards), they recover and begin arguing about whether or not they’ve really time traveled or not, an argument that would be a lot briefer if the Doctor would just open the damn doors already.
In the midst of this, we are introduced in Doctor Who to a tribe of cave folk, specifically one chap who’s angling for the leadership role. His dad apparently knew how to make with the fire, but neglected to pass the secret on, leaving his poor offspring to frantically play with his bone with nary a spark to show for it. (On the upside, he doesn’t seem to be going blind.)
Once they step outside and find themselves not in London but in a bleak, paleolithic landscape, their disbelief becomes a moot point. While they’re picking up horse skulls and generally gaping in wonder, the Doctor wanders off to have a smoke.
Yes, the Doctor smokes a pipe now. Pipes are cool in Doctor Who. Unfortunately, the Doctor is soon dragged away by a caveman who saw the Time Lord come out of his “tree” and make fire with his fingers (his matches). So I guess there’s a good lesson for the little ones after all. Don’t smoke or you’ll be kidnapped by a caveman. Stay in school, kids.
The rest of the Doctor Who gang soon realizes the Doctor is AWOL and set off to find him, eventually getting captured as well. And that’s basically it as far as narrative progress for this episode. While the previous ep kept things rolling with the mysteries of who and what the Doctor and Susan are, the leisurely pacing here is a lot more noticeable. Mainly because half of the episode is spent watching cave people argue about who should be in charge. Indecision 10,000 BC.
We’re left with a Doctor Who cliffhanger that isn’t terribly cliffhang-y, with the TARDIS travelers held captive in a cave full of split-open skulls, thus proving that cave people don’t play when it comes to making fire come from your fingers
https://www.giantfreakinrobot.com/ent/scifi/doctor-day-unearthly-child-cave-skulls.html
Had it been revealed at the end of episode four that this was actually a future vision of the Earth, following a nuclear holocaust, then it wouldn’t have come as a surprise. Maybe this was the original intention but got lost after one of the many rewrites? Not that it really matters, but it would have given the story an extra little frisson.
The tribe are a mixed bunch. Most mannered is Howard Lang as Horg who’s difficult to take seriously, although Derek Newark (Za), Alethea Charlton (Hur), Kal (Jeremy Young) and Eileen Way (Old Mother) are much better. All would return to the series in later years, as well as popping up in numerous other series of the time.
Za, Hur and Kal form an unlikely love triangle with Old Mother looking on ironically from the sidelines, constantly muttering that it would be better if Za never learns the secret of fire. It’s hard to understand her vehemence against fire, especially if one believes Za’s statement that without fire they’d die. Exactly why fire strikes such fear into her heart is never explained.
The initial TARDIS scene is notable for allowing the doors to open on the alien landscape. This wasn’t very common (although it would crop up again in The Sensorites) but I’m grateful they did it here since it really helps to sell the illusion of stepping from the ship into the unknown.
The forced perspective sets of the apparently endless plains may be obvious if you look too hard, but given the small amount of money Barry Newbery had to play with they’re still impressive. The wind sound effects help to create the impression that it’s freezing (although that makes the moment when Ian touches the sand and is astonished how cold it is, all the more strange).
We get the first of Susan’s hysterical fits, when the Doctor disappears – I really wish Barbara had slapped her hard as it might have discouraged her from doing it again! As for the Doctor, we see him enjoying a crafty smoke with a pipe – clearly this was only introduced so that Kal could see the Doctor make fire (or maybe the trauma in the Cave of Skulls was the moment he decided to kick the habit?)
Although Ian’s still in denial about everything, there’s also the first sign of his practical nature – after the Doctor disappears he automatically takes command. And when they’re all imprisoned in the Cave of Skulls it’s no surprise that Barbara is the one he checks on first (“Are you all right? Did they hurt you?”). Although never explicitly stated on-screen it seems obvious Barbara and Ian are very much a couple (as David Whitaker later confirmed in The Crusaders novelisation).
With the Doctor having seemingly lost all of his previous bluster (“Oh, I’m sorry. I’m sorry, it’s all my fault. I’m desperately sorry.”) things look bleak for our four heroes as they contemplate the myriad of skulls – all of which have been split open.
https://archivetvmusings.blog/2017/11/24/doctor-who-an-unearthly-child-part-two-the-cave-of-skulls/

The post Write up on Dr Who: Episode 2 – A Cave of Skulls appeared first on DayDreamin’ Comics.

In the Hollows, Wil realizes that Cephelo has stolen the Elfstones from him. Amberle falls and twists her ankle, and Wil is forced to leave her alone in the woods so he can go find the stones. As he runs on foot, he encounters Eretria, who has arrived on horseback to help him regain the stones. When they reach the Rovers’ camp, they discover that the Reaper has slaughtered everyone. Wil takes the Elfstones from Cephelo’s dead body.
At Arborlon, Ander fights bravely against demons. Men, rock trolls and dwarves unite to stand against the armies of evil, and Ander becomes a true leader, directing the warriors and rallying their fighting spirit. King Eventine is proud of his son’s accomplishments in battle, but still concerned about the future of the elves if Amberle’s mission fails.
At night, King Eventine’s faithful dog, Manx, attacks him, and he realizes that it is actually the Changeling Demon who has been posing as his dog for several weeks, spying on all his plans with Allanon and sending demons to attack Wil and Amberle. King Eventine kills the demon but is mortally wounded.
The witch Mallenroh kidnaps Amberle and takes her to her castle. Mallenroh demands that Wil give her the Elfstones so she can defeat her sister once and for all, but he refuses. Morag comes to Mallenroh’s castle, and the two fight over possession of the Elfstones, but they ignite a fire that kills them both.
Wil, Eretria, Amberle and Mallenroh’s servant, Wisp, escape the fire but are pursued by the Reaper. Wisp leads them to a cavern where Amberle finds the Bloodfire, but the Reaper enters the cavern as well and kills Wisp. When the Reaper reaches to kill Eretria, Will realizes that he must use the Elfstones, and that his previous inability to use the stones was actually a self-imposed fear of magic. He resolves to accept the Elfstones’ magic. After a fierce battle, he kills the Reaper with the Elfstones.
Amberle walks into the Bloodfire, but it does not burn her. She brings out the Ellcrys’ seed but realizes that she doesn’t just need to bathe the seed in the Bloodfire, she needs to absorb the Bloodfire herself. Wil uses the Elfstones to find their way out of the Safehold. Eretria carries a badly weakened Amberle. Perk arrives on his giant bird to carry them to Arborlon.
The Ellcrys dies, King Eventine lays dying of his wounds, and demons continue to attack. Prince Ander holds little hope for the future of the Four Lands. Allanon and the Dagda Mor duel each other on winged mounts until, with one great final effort, Allanon destroys him with Druid fire.
Perk lands in Arborlon, and Amberle dismounts and walks to the dead Ellcrys. She hugs the tree, which then disappears. Amberle begins to turn into a tree and within seconds she becomes the new Ellcrys. The Forbidding spell is restored, banishing all the demons, leaving the elves safe and free.
Wil is furious at Allanon for not telling him Amberle’s destiny, but Allanon insists that the final choice was Amberle’s. Allanon has aged greatly because he expended so much magical energy in the battles, and he says he needs to go away to rest. King Eventine dies, and Ander becomes the new king.
After a week of reconciling himself to the disappointing turn of events, Wil goes to see the Ellcrys and feels content with Amberle’s fate. He then invites Eretria to go home with him to Shady Vale where he will pursue his own destiny as a Healer. Eretria accepts his offer and takes his hand.
Literature Collection Sample:
In the elven city of Arborlon, the Chosen take care of the Ellcrys, a magical tree that guards the earth against demons. The Ellcrys maintains an ancient spell called the Forbidding, which keeps demons from re-entering the world. The Chosen notice that the always-healthy Ellcrys is wilting. She telepathically communicates with the Chosen, revealing that she is dying. A demon called Dagda Mor and his henchmen, the Reaper and Changeling, force their way through a breach in the Forbidding spell and enter Arborlon.
Elven Prince Ander Elessedil, second son of King Eventine Elessedil, brings one of the Chosen to the King. The Chosen explains that the Ellcrys can be reborn after her death and the Forbidding spell can be restored. One of the Chosen must take her seed to the fountain of the Bloodfire in a maze called the Safehold, plunge it into the fire and then return to Arborlon and plant it.
Demons kill the six young Chosen elves, apparently preventing all hope of the Ellcrys’ rebirth. However, one of the Chosen, Amberle, the granddaughter of King Eventine Elessedil, is still living. No one knows where she is because she abandoned her duty and ran away a few months prior.
Allanon, the great Druid, comes to Arborlon. Ander thought Allanon was dead because no one had seen him for 50 years after he helped Shea Ohmsford defeat the Warlock Lord with the legendary Sword of Shannara. Since the elves do not know the location of the Safehold, Allanon offers to go to the ancient libraries at Paranor to gain more information. At Paranor, Dagda Mor unleashes Fury Demons on Allanon, but Allanon manages to escape.
In the Eastland, the Gnome village of Storlock is well-known as a colony of the best Healers in the Four Lands, and young Wil Ohmsford is the only non-Gnome receiving Healer training. A bleeding Allanon arrives for medical treatment and asks Wil to go on a journey with him to find the elvish Princess Amberle, the last Chosen. Wil agrees and takes the Elfstones, which are three magical blue stones from the ancient world, with him.
They arrive at the village of Heavenstead and attempt to persuade Amberle to leave with them, but she believes she is forever outcast from elvish society for giving up the honor of being Chosen. When demon-wolves arrive in Heavenstead to kill Amberle, she flees with Allanon and Wil on horseback.
As they approach the magical Silver River, Allanon falls off his horse and is attacked by demons. Wil and Amberle’s horse Artaq jumps from the riverbank and is transported far away to the realm of the ancient King of the Silver River. He makes Wil and Amberle sleep, then sends them to the kingdom of Callahorn.
Wil and Amberle encounter Rovers, a traveling group of thieves and tricksters. Their leader, Cephelo, steals Artaq, but Wil cleverly meets up with the Rovers and asks to travel with them in order to get the horse back. Cephelo’s beautiful young ward, Eretria, offers to help Wil, to whom she is attracted.
When a giant demon attacks the Rovers, Wil uses the Elfstones to burn the creature to death. The Rovers give him back Artaq, and he and Amberle flee, pursued by demons they narrowly evade. Allanon reappears and guides them safely to Arborlon.
Allanon mentions that since Wil is three-quarters human and only one-quarter Elf, he may have trouble accessing the power of the Elfstones in the future. The Ellcrys gives Amberle her seed, and the elves form a guard to escort Amberle to the Bloodfire, which is inside the Safehold in the dangerous Wilderun in the Westland.
The elven Hunters protecting Amberle and Wil are killed off two and three at a time by the Reaper, who follows them from place to place. Wil realizes that the demons know where the elven Hunters are going, so there must be a spy in Arborlon informing on them. The Reaper finally catches up to Wil and Amberle, but when Wil attempts to fight him with the Elfstones, the power is gone, leaving him on his own. Wil manages to cut down a high, precarious catwalk that the Reaper is crossing, which makes the Reaper fall and allows Wil and Amberle to escape.
They meet a young elf boy named Perk, who is a Wing Rider in training. He offers to let them fly on his giant bird, Genewen. The elves in Perk’s tribe ride on birds called Rocs and have very little contact with elves from other areas. Perk flies them to the Wilderun, where they disembark.
Allanon goes to Arborlon just before The Forbidding spell breaks completely, unleashing endless hoards of demons into Halys Cut, a gorge near Arborlon. King Eventine is severely wounded in battle. The elves retreat, and Ander receives word that demons have killed his older brother, Arion, making him the last Elessedil to rule the elves.
In the Wilderun, Wil and Amberle go to a rough town called Grimpen Ward and are rescued by Eretria, who is still traveling with Cephelo. Cephelo says that only he and his Rovers can help Wil find Safehold, but that he wants the Elfstones in payment for his services. Wil doesn’t agree.
But Cephelo takes them to an old man named Hebel who says the Safehold lies in on a peak called the Spire’s Reach inside the Hollows, a dark place ruled by the Witch Sisters Morag and Mallenroh. He says that the sisters rule different sides of the Hollows and fight bitterly against each other. The Spire’s Reach is directly in the center of their territory. Eretria begs to go with Wil, but he refuses her offer of help because he thinks the Hollows are too dangerous.
In the Hollows, Wil realizes that Cephelo has stolen the Elfstones from him. Amberle falls and twists her ankle, and Wil is forced to leave her alone in the woods so he can go find the stones. As he runs on foot, he encounters Eretria, who has arrived on horseback to help him regain the stones. When they reach the Rovers’ camp, they discover that the Reaper has slaughtered everyone. Wil takes the Elfstones from Cephelo’s dead body.
At Arborlon, Ander fights bravely against demons. Men, rock trolls and dwarves unite to stand against the armies of evil, and Ander becomes a true leader, directing the warriors and rallying their fighting spirit. King Eventine is proud of his son’s accomplishments in battle, but still concerned about the future of the elves if Amberle’s mission fails.
At night, King Eventine’s faithful dog, Manx, attacks him, and he realizes that it is actually the Changeling Demon who has been posing as his dog for several weeks, spying on all his plans with Allanon and sending demons to attack Wil and Amberle. King Eventine kills the demon but is mortally wounded.
The witch Mallenroh kidnaps Amberle and takes her to her castle. Mallenroh demands that Wil give her the Elfstones so she can defeat her sister once and for all, but he refuses. Morag comes to Mallenroh’s castle, and the two fight over possession of the Elfstones, but they ignite a fire that kills them both.
Wil, Eretria, Amberle and Mallenroh’s servant, Wisp, escape the fire but are pursued by the Reaper. Wisp leads them to a cavern where Amberle finds the Bloodfire, but the Reaper enters the cavern as well and kills Wisp. When the Reaper reaches to kill Eretria, Will realizes that he must use the Elfstones, and that his previous inability to use the stones was actually a self-imposed fear of magic. He resolves to accept the Elfstones’ magic. After a fierce battle, he kills the Reaper with the Elfstones.
Amberle walks into the Bloodfire, but it does not burn her. She brings out the Ellcrys’ seed but realizes that she doesn’t just need to bathe the seed in the Bloodfire, she needs to absorb the Bloodfire herself. Wil uses the Elfstones to find their way out of the Safehold. Eretria carries a badly weakened Amberle. Perk arrives on his giant bird to carry them to Arborlon.
The Ellcrys dies, King Eventine lays dying of his wounds, and demons continue to attack. Prince Ander holds little hope for the future of the Four Lands. Allanon and the Dagda Mor duel each other on winged mounts until, with one great final effort, Allanon destroys him with Druid fire.
Perk lands in Arborlon, and Amberle dismounts and walks to the dead Ellcrys. She hugs the tree, which then disappears. Amberle begins to turn into a tree and within seconds she becomes the new Ellcrys. The Forbidding spell is restored, banishing all the demons, leaving the elves safe and free.
Wil is furious at Allanon for not telling him Amberle’s destiny, but Allanon insists that the final choice was Amberle’s. Allanon has aged greatly because he expended so much magical energy in the battles, and he says he needs to go away to rest. King Eventine dies, and Ander becomes the new king.
After a week of reconciling himself to the disappointing turn of events, Wil goes to see the Ellcrys and feels content with Amberle’s fate. He then invites Eretria to go home with him to Shady Vale where he will pursue his own destiny as a Healer. Eretria accepts his offer and takes his hand.

The post Write up on The Elfstones of Shannara by Terry Brooks appeared first on DayDreamin’ Comics.

Plot Summary
Morning Tension and Family Dynamics
Bigger awakens to a tense morning
In a cramped Chicago apartment, Bigger Thomas wakes to the sound of an alarm, surrounded by his family. The morning is filled with tension as his mother expresses frustration over their dire living conditions and Bigger’s lack of ambition. This environment of bickering and dissatisfaction sets the stage for Bigger’s internal conflict. He feels trapped by his circumstances and is reminded of a job interview with the wealthy Dalton family, which represents both an opportunity and a reminder of the racial and social barriers he faces. The oppressive atmosphere highlights Bigger’s struggle with his identity and the societal forces that confine him.
Bigger’s Desperate Calculations
Bigger’s mind races with fear
After accidentally killing Mary Dalton, Bigger is engulfed by fear and desperation. In a frantic attempt to cover up the crime, he decides to burn her body in the furnace. As he moves through the Dalton household, he is acutely aware of the racial and social barriers that separate him from the white family. His actions are driven by a mix of panic and a desire to assert control over his life, even as he feels the walls closing in around him. This moment marks the beginning of a series of desperate decisions that will define his fate.
The Kidnap Note Scheme
Bigger devises a risky plan
In a bid to deflect suspicion and gain money, Bigger concocts a plan to send a ransom note to the Daltons, pretending that Mary has been kidnapped. He enlists his girlfriend Bessie in the scheme, manipulating her fear and loyalty. The plan is fraught with danger, as Bigger must navigate the suspicions of the Dalton family and the private investigator, Britten, who is probing into Mary’s disappearance. This scheme highlights Bigger’s desperation and the lengths he will go to in order to maintain control over his precarious situation.
A Web of Lies and Deception
Bigger’s lies begin to unravel
As the investigation into Mary’s disappearance intensifies, Bigger is questioned by Britten and the Daltons. He fabricates a story implicating Jan, Mary’s Communist boyfriend, in the kidnapping. Bigger’s lies are a desperate attempt to maintain control, but the pressure mounts as the media and police become involved. The tension escalates as Bigger realizes the precariousness of his situation and the likelihood of being discovered. This chapter underscores the fragility of Bigger’s deception and the inevitable collapse of his carefully constructed facade.
Discovery and Escape
Bigger’s crime is uncovered
The discovery of Mary’s remains in the furnace by reporters and investigators forces Bigger to flee. The realization that his crime has been exposed propels him into a frantic escape through the snow-covered streets of Chicago. Bigger’s flight is driven by a primal instinct for survival, as he grapples with the consequences of his actions and the inevitability of capture. This moment marks a turning point in the narrative, as Bigger’s world unravels and he is forced to confront the reality of his situation.
Bigger’s Desperate Confession
Bigger confesses under pressure
After being captured, Bigger Thomas is overwhelmed by the enormity of his crimes. He is questioned relentlessly by Buckley, the State’s Attorney, who manipulates Bigger into confessing to the murders of Mary Dalton and Bessie Mears. Bigger is trapped in a web of lies and fear, realizing that his actions have sealed his fate. Despite his confession, he struggles with the idea that his life has been reduced to a series of desperate acts driven by fear and societal oppression. This chapter highlights the crushing weight of Bigger’s reality and the forces that have shaped his life.
The Trial and Public Outcry
Public demands justice for crimes
Bigger’s trial becomes a spectacle, with the public and media demanding swift justice. The courtroom is filled with tension as Buckley presents a damning case against Bigger, painting him as a monstrous figure. The trial is not just about Bigger’s guilt but also a reflection of the racial tensions and prejudices of the time. The mob outside the courthouse symbolizes the societal pressure to punish Bigger as a scapegoat for broader racial fears. This chapter underscores the societal forces at play and the role of public opinion in shaping the outcome of the trial.
Max’s Plea for Understanding
Max argues for Bigger’s humanity
Boris Max, Bigger’s lawyer, delivers a passionate plea, urging the court to consider the societal forces that shaped Bigger’s actions. He argues that Bigger is a product of systemic racism and poverty, and that his crimes are a desperate response to a life of oppression. Max’s speech highlights the need for empathy and understanding, challenging the court to see Bigger as a human being rather than a mere criminal. This chapter emphasizes the novel’s critique of societal structures and the need for compassion in the face of injustice.
Bigger’s Inner Turmoil
Bigger grapples with his identity
As the trial progresses, Bigger is consumed by inner conflict. He reflects on his life, realizing that his actions were driven by a deep-seated fear and anger. He struggles to reconcile his desire for freedom with the reality of his situation. Bigger’s introspection reveals his longing for identity and meaning in a world that has consistently denied him both. This chapter delves into Bigger’s psyche, exploring the complexities of his character and the forces that have shaped his life.
Facing the Inevitable End
Bigger accepts his fate
With the trial concluding and the death sentence looming, Bigger comes to terms with his impending execution. He finds a sense of peace in acknowledging his actions and the societal forces that led him to this point. In his final moments, Bigger seeks understanding and connection, hoping that his life and death will serve as a testament to the struggles faced by those like him. This chapter brings the narrative to a poignant close, highlighting the novel’s themes of identity, oppression, and the search for meaning.
https://sobrief.com/books/native-son

Literature Sample Collection:
FEAR

“Yeah!” Gus said with uneasy eagerness. His eyes were
full of a look compounded of fear and admiration for Bigger.
“Yeah; I know what you mean. It’s like you going to fall and
don’t know where you going to land. . . .’’

Gus’s voice trailed off. The sun slid behind a big white
cloud and the street was plunged in cool shadow; quickly
the sun edged forth again and it was bright and warm once
more. A long sleek black car, its fenders glinting like glass in
the sun, shot past them at high speed and turned a comer a
few blocks away. Bigger pursed his lips and sang;
“Zoooooooooom! ’’

“They got everything,” Gus said.

“They own the world,” Bigger said.

“Aw, what the hell,” Gus said. “Let’s go in the poolroom.”
“O.K.”

‘They walked toward the door of the poolroom.

“Say, you taking that job you told us about?” Gus asked.

“I don’t know.”

“You talk like you don’t want it ”

“Oh, hell, yes! I want the job,” Bigger said.

They look^ at each other and laughed. They went inside.
The poolroom was empty, save for a fat, black man who held
a half-smoked, unlit cigar in his mouth and leaned on the
front counter. To the rear burned a single green-shaded bulb.
“Hi, Doc,” Bigger said.

“You boys kinda early this morning,” Doc said.

“Jack or G.H. around yet?” Bigger asked.

“Naw,” Doc said.

“Let’s shoot a game,” Gus said.

“I’m broke,” Bigger said.

“I got some money.”

“Switch on the light. The balls are racked,” Doc said.
Bigger turned on the light. They lagged for first shot. Bigger
won They started playing Bigger’s shots were poor; he was
thinking of Blum’s, fascinated with the idea of the robbery,
and a little afraid of it.

“Remember what we talked about so much?” Bigger asked
in a flat, neutral tone,

“Naw.”

“Old Blum.”

“Oh,” Gus said. “We ain’t talked about that for a month.
How come you think of it all of a sudden?”

“Let’s clean the place out.”

“I don’t know.”

“It was your plan from the start,” Bigger said.

Gus straightened and stared at Bigger, then at Doc who was
looking out of the front window.

“You going to tell Doc? Can’t you never learn to talk low?”
“Aw, I was just asking you, do you want to try it?”

“Naw ”

“How come? You scared ’cause he’s a white man?”
“Naw. But Blum keeps a gun. Suppose he beats us to it?”
“Aw, you scared; that’s all. He’s a white man and you
scared.”

“The hell I’m scared,” Gus, hurt and stung, defended him-
self.

Bigger went to Gus and placed an arm about his shoulders.
“Listen, you won’t have to go in. You just stand at the door
and keep watch, see? Me and Jack and G.H.’ll go in If any-
body comes along, you whistle and we’ll go out the back way.
That’s all.”

The front door opened; they stopped talking and turned
their heads.

“Here comes Jack and G.H. now,” Bigger said.

Jack and G.H. walked to the rear of the poolroom.

“What you guys doing?” Jack asked.

“Shooting a game. Wanna play?” Bigger asked,

“You asldng ’em to play and I’m paying for the game,” Gus
said.

They all laughed and Bigger laughed with them but stopped
quickly. He felt that the joke was on him and he took a
seat alongside the wall and propped his feet upon the rungs
of a chair, as though he had not heard. Gus and G.H. kept on
laughing.

“You niggers is crazy,” Bigger said. “You laugh like mon-
keys and you ain’t got nerve enough to do nothing but talk.”
“What you mean?” G.H. asked.

“I got a haul all figured out,” Bigger said.

“What haul?”

“Old Blum’s.”

There was silence. Jack lit a cigarette. Gus looked away,
avoiding the conversation.

“If old Blum was a black man, you-all would be itching to
go. ’Cause he’s white, everybody’s scared.”

PEAR

“I ain’t scared,” Jack said, “I’m with you.”

“You say you got it all figured out?” G H. asked.

Bigger took a deep breath and looked from face to face. It
seemed to him that he should not have to expla’m.

“Look, it’ll be easy. There ain’t nothing to be scared of. Be-
tween three and four ain’t nobody in the store but the old
man. The cop is way down at the other end of the block. One
of us’ll stay outside and watch. Three of us’ll go in, see? One
of ns’ll throw a gun on old Blum; one of us’ll make for the
cash box under the counter, one of us’ll make for the back
door and have it open so we can make a quick get-away
down the back alley. . . . That’s all. It won’t take three min-
utes.”

“I thought we said we wasn’t never going to use a gun,”
G.H. said. “And we ain’t bothered no white folks before.”

“Can’t you see? This is something big,” Bigger said.

He waited for more objections. When none were forth-
coming, he talked again.

“We can do it, if you niggers ain’t scared.”

Save for the sound of Doc’s whistling up front, there was
silence. Bigger watched Jack closely; he knew that the sit-
uation was one in which Jack’s word would be decisive. Bigger
was afraid of Gus, because he knew that Gus would not
hold out if Jack said yes. Gus stood at the table, toying with
a cue stick, his eyes straying lazily over the billiard balls
scattered about the table in the array of an unfinished game.
Bigger rose and sent the balls whirling with a sweep of his
hand, then looked straight at Gus as the gleaming balls kissed
and rebounded from the rubber cushions, zig-zagging across
the table’s green cloth. Even though Bigger had asked Gus
to be with him in the robbery, the fear that Gus would really
go made the muscles of Bigger’s stomach tighten; he was hot
all over. He felt as if he wanted to sneeze and could not; only
it was more nervous than wanting to sneeze. He grew hotter,
tighter; his nerves were taut and his teeth were on edge. He
felt that something would soon snap within him.

“Goddammit! Say something, somebody!”

“I’m in,” Jack said again.

“rU go if the rest goes,” G.H. said.

Gus stood without speaking and Bigger felt a curious
sensation — half-sensual, half-thoughtful. He was divided and
pulled agamst himself. He had handled things just nght so

far; all but Gus had consented. The way things stood now
there were three against Gus, and that was just as he had
wanted it to be. Bigger was afraid of robbing a white man and
he knew that Gus was afraid, too. Blum’s store was smaU and
Blum was alone, but Bigger could not think of robbing him
without being flanked by his three pals. But even with his paU
he was afraid. He had argued all of his pals but one into
consenting to the robbery, and toward the lone man who held
out he felt a hot hate and fear; he had transferred his fear
of the whites to Gus. He hated Gus because he knew that
Gus was afraid, as even he was; and he feared Gus because
he felt that Gus would consent and then he would be com-
pelled to go through with the robbery. Like a man about to
shoot himself and dreading to shoot and yet knowing that he
has to shoot and feeling it all at once and powerfully, he
watched Gus and waited for him to say yes. But Gus did not
speak. Bigger’s teeth clamped so tight that his jaws ached. He
edged toward Gus, not looking at Gus, but feeling the pres-
ence of Gus over all his body, through him, in and out of
him, and hating himself and Gus because he felt it. Then he
could not stand it any longer. The hysterical tensity of his
nerves urged him to speak, to free himself. He faced Gus,
his eyes red with anger and fear, his fists clenched and held
stiffly to his sides.

“’i’^ou black sonofabitch,” he said in a voice that did not
vary in tone. “You scared ’cause he’s a white man.”

“Don’t cuss me. Bigger,” Gus said quietly.

“I am cussing you!’’

“You don’t have to cuss me,” Gus said.

“Then why don’t you use that black tongue of yours?”
Bigger asked. “Why don’t you say what you going to do?”

“I don’t have to use my tongue unless I want to!”

“You bastard! You scared bastard!”

“You ain’t my boss,” Gus said.

“You yellow!” Bigger said. “You scared to rob a r^diite
man.”

“Aw, Bigger. Don’t say that,” G.H. said. “Leave ’im alone.”

“He’s yellow,” Bigger said “He won’t go with us.”

“I didn’t say I wouldn’t go,” Gus said.

“Then, for chrissakes, say what you going to do,” Bigger
said.

Gus leaned on his cue stick and gazed at Bigger and Bigger’s

Stomach tightened as though he were expecting a blow and
were getting ready for it. His fists clenched harder In a split
second he felt how his fist and arm and body would feel if
he hit Gus squarely in the mouth, drawing blood; Gus would
fall and he would walk out and the whole thing would be
over and the robbery would not take place. And his thinking
and feeling in this way made the choking tightness rising
from the pit of his stomach to his throat slacken a little.

“You see, Bigger,” began Gus in a tone that was a com-
promise between kindness and pride. “You see. Bigger, you
the tause of all the trouble we ever have. It’s your hot temper.
Now, how come you want to cuss me? Ain’t 1 got a right to
make up my mind? Naw; that ain’t your way. You start cuss-
ing. You say I’m scared. It’s you who’s scared. You scared
I’m going to say yes and you’U have to go through with the
job. . .

“Say that again! Say that again and I’ll take one of these
balls and sink it in your goddamn mouth,” Bigger said, his
pride wounded to the quick.

“Aw, for chrissakes,” Jack said.

“You see how he is,” Gus said.

“Why don’t you say what you going to do?” Bigger de-
manded.

“Aw, I’m going with you-all,” Gus said in a nervous tone
that sought to hide itself; a tone that hurried on to other
things. “I’m going, but Bigger don’t have to act like that. He
don’t have to cuss me.”

“Why didn’t you say that at first?” Bigger asked; his anger
amounted almost to frenzy. “You make a man want to sock
youl”
http://daydreaminstudios.org/free-library-read/richard-wright-native-son

References:
http://daydreaminstudios.org/free-library-read/richard-wright-native-son
https://www.math.buffalo.edu/~sww/wright/wright_bio.html
https://sobrief.com/books/native-son

The post Write up on Richard Wright’s native Son appeared first on DayDreamin’ Comics.

As the initial struggle to end apartheid was coming to an end so did the ban on Themba’s voice in South Africa in 1982, fourteen years after his death.[lii] Around two decades after this, on September 27, 2006, Themba was awarded The Order of Ikhamanga[liii] in Silver for ‘excellent achievement in literature, contributing to the field of journalism and striving for a just and democratic society in South Africa’ from the president of South Africa at that time.’[liv] During the time that he was alive, Themba had also received another award: Henry Nxumalo[lv] Award for journalism from the Writer’s Association of South Africa.[lvi] The struggle still goes on to fix all the broken pieces of Themba’s land that was once so peaceful. However, as the process continues, the world must not forget the men like Can Themba. The men who lived and died fighting this battle without ever getting to witness the light at the end of the tunnel.

Significance of the Study
Can Themba’s key literature books were banned one discusses literature of South African apartheid Cam Themba should be mentioned and recognized as a key South African Author during this dark time in South Africa. These Collections were buried in the sands because it was a topic that South Africa does publicly mention on a global scale. Can Themba books were banned because he was considered a Communist or Non National Rebel in the eyes of the South Africa Government
The Will to Die
In this collection of previously banned short stories, Can Themba shines a light on the racism and systemic violence suffered by Black South Africans during apartheid in the late 1950s. Written during Can Themba’s career as an investigative journalist for South Africa’s revolutionary magazine Drum , these seventeen short stories capture the atrocities of apartheid as he witnessed and experienced them first-hand. In Themba’s most famous short-story, ‘The Suit’, a couple living in poverty struggle to find freedom from oppression and from each other. Set in Sophiatown, the tales preludes the South African government’s decision to bulldoze the homes of Black residents and make way for a white-only suburb – an event that personally devastated Can Themba and shaped the rest of his writing career. This is the essential collection of his most impactful stories, written in defiance of the injustice he witnessed.
The Suit
The story of The Suit takes place in Sophiatown, a Johannesburg township, and centers on Philemon, who works for a middle class lawyer and his wife Matilda. He loves his wife and seems happy with his life until he finds out that she has been seeing another man. He surprises her with her lover who leaves in a rush leaving his suit behind. Philemon then devises a rather unique form of punishment: the suit must be treated as an honored guest and the wife must take it wherever she goes as a reminder of her betrayal. William Nadylam plays a husband in full control of the situation, only revealing true emotion at the end when he holds her dead in his arms. Beautiful Nonhlanhla Kheswa’s Matilda, whose choices in life are so limited, comes alive when she can sing or love.

Literature Sample Collection
The Suit:

FIVE-THIRTY in the morning, and the candlewick bedspread frowned as the man under it stirred. He did not like to wake his wife lying by his side — as yet; so he crawled up and out by careful peristalsis. But before he tip-toed out of his room with shoes and socks under his arm, he leaned over and lieered at the sleeping serenity of his wife; to him a daily matutinal miracle.

He grinned and yawned simultaneously, offering his wordless Te Deum to whatever gods for the goodness of life; for the pure beauty of his wife; for the strength surging through his willing body; for the even, unperturbed rhythms of his passage through days and months and years — it must be — to heaven. Then he slipped soundlessly into the kitchen. He flipped aside the curtain of the kitchen window, and saw outside a thin drizzle, the type that can soak one to the skin, and that could go on for days and days.
He wondered, head aslant, why the rain in Sophiatown always came in the morning when workers have to creep out of their burrows; and then blistering heat waves during the day when messengers have to run errands all over; and then at how even the rain came back when workers knock off and have to scurry’ home. He smiled at the odd caprice of the heavens, and tossed his head at the naughty incongruence, as if: “Ai, but the gods!” From behind the kitchen door, he removed an old rain cape, peeling off in places, and swung it over his head.
He dashed for the lavatory , nearly slipping in a pool of muddy water, but he reached the door. Aw, blast, someone had made it before him. Well, that is the toll of staying in a yard where tw’enty . . . thirty other people have to share the same lean-to. He was dancing and burning in that climactic moment when trouser-fly will not come wide soon enough. He stepped round the lavatory and watched the streamlets of rain-water quickly wash away the jet of tension that spouted from him. That infinite after-relief. Then he dashed back to his kitchen. He grabbed the old baby bath-tub hanging on a nail on under the slight shelter of the gutterless roof-edge.
He opened a large wooden box and quickly filled the bath-tub with coal. Then he inched his way back to the kitchen door and inside. He was huh-huh-huhing one of those fugitive tunes that cannot be bidden, but often just occur and linger, naggingly, in his head, and the fire he was making soon licked up cheerfully, in mood with his contentment. He had a trick for these morning chores.
While the fire in the old stove warmed up, the water kettle humming on it, he gathered and laid ready the things he would need for the day: brief case and the files that go with it; the book that he was reading currently; the letters of his lawyer of a boss which he usually posted before lie reached the office; his wife’s and his own dry cleaning slips for the Sixty-.Minutes; his lunch tin solicitously prepared the night before by his attentive wife. And, to-day, the battered rain cape. By the time the kettle on the stove sang (before it actually boiled),he poured water from it into a wash basin, refilled the kettle and replaced it on the stove.
Then he washed himself carefully: across the eyes, along the nose bridge, up and down the cheeks, around the ears, under, in and out the armpits, down the torso and in between the legs. This ritual was thorough, though no white man a-complaining of the smell of wogs knows anything about it.
Then he dressed himself fastidiously. By this time he was ready to prepare breakfast. Breakfast! How he enjoyed taking round a tray of warm breakfast to his wife, cuddled in bed. To appear there in his supremest immaculacy, tray in hand when his wife comes out of ether to behold him. These things we blacks want to do for our own . . .not fawningly for the whiles for whom we bloody-well got to do it.
He felt, be denied that he was one of those who believed in putting his wife in her place even if she was a good wife. Not he. Matilda, too, appreciated her husband’s kindness, and only put her foot down v/hen he offered to wash up also. “Off with you” she scolded him on his way.
At the bus-stop he was a little sorry to see that jovial old Maphikela was in a queue for a bus ahead of him. He would miss Maphikela’s raucous laughter and uninhibited, bawdy conversations in fortissimo. Maphikela hailed him nevertheless. He thought he noticed hesitation in the old man, and slight clouding of his countenance, hut the old man shouted back at him, saying that he would wait for him at the terminus in town. Philemon always considered this morning trip to town with garrulous old Maphikela as his daily bulletin. All the township news was generously reported by loud-mouthed heralds, and spiritedly discussed by the bus at large.

The post Write up on Can Themba appeared first on DayDreamin’ Comics.

Limitations were present because programs should contain only one instruction per row and every row should start with a command, but the “Dartmouth BASIC” was compiled and rather fast for that time. The efforts of Kemeney and Kurtz were repaid on May 1, 1964 when, at 4:00 am, two BASIC programs ran simultaneously on the General Electric 225 mainframe at Dartmouth College.

WHAT IS ATARI BASIC?
ATARI BASIC is an interpreted language. This means programs can be run when they are entered without intermediate stages of compilation and linking. The ATARI BASIC interpreter resides in an 8K ROM cartridge in the left slot of the computer. It encompasses addresses A000 through BFFF. At least 8K of RAM is required to run BASIC.
To use ATARI BASIC effectively, you must know its strengths and weaknesses. With this information, programs can be written that make good use of the assets and features of ATARI BASIC.

Strengths of ATARI BASIC
o It supports the operating system graphics – Simple graphics calls can be made to display information on the screen.
o It supports the hardware – Such calls as SOUND, STICK and PADDLE are simple interfaces to the hardware of the computer.
o Simple assembly interface – The USR function allows easy user access to assembly language routines.
o ROM based interpreter – The BASIC interpreter is in ROM, which prevents accidental modification by the user program.
o DOS support – Specialized calls such as NOTE and POINT (DOS 2.0S) allow the user to randomly access a disk through the disk operating system.
o Peripheral support – Any peripheral recognized by the operating system can be accessed from a BASIC program.
Weaknesses of ATARI BASIC
o No support of integers – All numbers are stored as 6-byte BCD floating point numbers.
o Slow math package – Since all numbers are six bytes long, math operations become rather slow.
o No string arrays – Only one-dimensional strings can be created.
https://www.atariarchives.org/dere/chapt10.php

The very beginning in 1978, Atari’s intention was to buy a licence for a BASIC that was commonly used at the time — Microsoft BASIC — and to offer it as standard BASIC on the future Atari 400 & 800. Two slightly different versions of Microsoft BASIC were available for 6502 CPU/microprocessor, but they were poorly documented. What’s more, Atari obviously wanted to add instructions to take advantage of the Atari 400 & 800’s extraordinary graphics and sound capabilities, joysticks and paddles, and so on.
Since Microsoft wasn’t much help, Atari solicited the help of an outside company in September 1978: SMI (Shepardson Microsystems Inc), which already had a great deal of experience in developing BASIC on the 6502. Very quickly, SMI suggested dropping the idea of using Microsoft BASIC{2}{3} and proposed another version, built using Atari’s technical specifications. SMI delivered Atari BASIC (along with Atari DOS I) in December 1978.
{2} To stop reading reccurent, unpleasant comments in magazines pointing out that Atari BASIC was not an offshoot of Microsoft BASIC, Atari ended up offering its own Atari Microsoft BASIC in 1981, two years after the launch of Atari BASIC.

{3} This is how Atari advertised the Atari Microsoft BASIC and the Atari BASIC in publications around 1982. I have scrupulously respected the use of upper and lower case letters as they appear in the advertisement.

ATARI Microsoft BASIC — Now we offer the industry standard, the most powerful Microsoft BASIC yet. With simple commands, it allows you to take advantage of unique Atari hardware features such as our well-known player/missile graphics [that is, sprites]. For ease of programming, it includes n-dimensional arrays for numerics and string handling. And importantly, conversion procedures are simple.
ATARI BASIC — An affordable and easy to use BASIC that requires only 8 KiB of memory. It allows you to take advantage of the spectacular ATARI graphics and sound capabilities. And its immediate mode error messages greatly simplify debugging.
And now the question on everybody’s lips: “Why can’t Atari BASIC handle string arrays?”
Positioning Atari computers in the educational market was a real priority for Atari.
It should also be pointed out that a very strong technical constraint had to be respected for the creation of Atari BASIC: as the Atari 400 & 800 were designed as easy-to-use machines, BASIC would be offered on an 8 KiB cartridge so that it would be available immediately, when the computer was started up — and not in the form of software to be loaded from diskette or cassette tape{4}. So, the “must fit on an 8 KiB cartridge” constraint was central to the user experience. Atari at one point considered using the 2nd cartridge slot (“RIGHT CARTRIDGE”) of the Atari 800 to offer a 2nd cartridge that would complement the existing Atari BASIC in the 1st cartridge slot with an extended version, of 8 KiB + 8 KiB = 16 KiB. This 2nd cartridge never materialised.
{4} Loading an external BASIC from diskette or cassette tape complicates and slows down the boot process. Of course, there are also advantages, such as the possibility to have a BASIC on 10 KiB or more. Or the possibility to offer a new version more quickly, and at a limited cost. But it also assumes that the computer user owns a floppy disk drive or a cassette tape player/recorder.
So, to “squeeze” Atari BASIC into 8 KiB, compromises had to be made.
For instance:
• The FPP (Floating Point Package) routines module has been moved to ROM, and is part of the system OS — although it is never used by the OS.
• No classic instruction like CLS in Atari BASIC, because an equivalent exists: GR.0 abbreviation of GRAPHICS 0.
• The I/O routines as well as the graphics{5} routines are in fact implemented in the OS, and simply “called” with the expected parameters by Atari BASIC.
One oversight: the FILL function for filling a shape on the screen exists in the OS but is not available directly in Atari BASIC: you have to use the generic XIO 18 instruction.
• There are no graphical instructions for drawing circles or ovals in Atari BASIC: you have to draw them yourself point by point, with the slowness you can imagine for sine and cosine calculations in BASIC.
• More embarrassingly, there were no instructions for building and managing sprites (players-missiles in Atari’s vocabulary) in Atari BASIC, a decisive factor in the graphic superiority of Atari 400 & 800 computers over their competitors at the time: you had to use PEEK and POKE instructions to implement them.
• The Atari BASIC SOUND instruction allows you to create fairly basic sounds on 4 separate 8-bit channels with the POKEY chip, whereas you can aggregate 2 channels to obtain a 16-bit channel with POKE instructions for instance. Even worse, the SOUND instruction does not manage the duration of the sound, nor its envelope…
{5} Have you ever wondered how the same Atari BASIC, REV. A from 1979, miraculously handles the additional graphics modes that were implemented in 1982 and 1983, long AFTER that version of Atari BASIC was released? I’m talking about the additional graphics modes that appeared when CTIA was replaced by GTIA, and about the additional graphics modes that appeared with the 1200XL?
The answer is simple: Atari BASIC doesn’t know which graphics modes are actually available on the computer it is running on. More generally, Atari BASIC knows nothing of graphic modes, display lists, character sets, color registers, etc. Atari BASIC simply knows which parameters to use to call routines which, in fact, are implemented in the OS (operating system), and are therefore subject to change and update.
It may seem surprising and puzzling, but all the graphic instructions available in Atari BASIC are in fact simple instructions, nice and friendly to use, which all mask simple calls to routines that are all implemented in the OS.
The Atari BASIC editor offered enormous flexibility compared with other computers of the time.
Atari BASIC is not a compiled language.

https://www.atari800xl.eu/docs/kb/kb-software-0005-atari-basic-overview.html
The programming language which has become the de facto standard for the Atari Home Computer is the Atari 8K BASIC Cartridge, known simply as Atari BASIC. It was designed to serve the programming needs of both the computer novice and the experienced programmer who is interested in developing sophisticated applications programs. In order to meet such a wide range of programming needs, Atari BASIC was designed with some unique features. In this chapter we will introduce the concepts of high level language translators and examine the design features of Atari BASIC that allow it to satisfy such a wide variety of needs. Language Translators Atari BASIC is what is known as a high level language translator. A language, as we ordinarily think of it, is a system for communication. Most languages are constructed around a set of symbols and a set of rules for combining those symbols. The English language is a good example. The symbols are the words you see on this page. The rules that dictate how to combine these words are the patterns of English grammar. Without these patterns, communication would be very difficult, if not impossible : Out sentence this believe, of make don’t this trying if sense you to! If we don’t use the proper symbols, the results are also disastrous: @twu2 yeggopt gjsiem, keorw? In order to use a computer, we must somehow communicate with it. The only language that our machine really understands is that strange but logical sequence of ones and zeros known as machine language. In the case of the Atari, this is known as 6502 machine language. When the 6502 central processing unit (CPU) “sees” the sequence 01001000 in just the right place according to its rules of syntax, it knows that it should push the current contents the accumulator onto the CPU stack. (If you don’t know what an “accumulator” or a “CPU stack” is, don’t worry about it. For the discussion which follows, it is sufficient that you be aware of their existence.) Language translators are created to make it simpler for humans to communicate with computers. There are very few 6502 programmers, even among the most expert of them, who would recognize 01001000 as the push-the-accumulator instruction. There are more 6502 programmers, but still not very many, who would recognize the hexadecimal form of 01001000, $48, as the push-the-accumulator instruction. However, most, if not all, 6502 programmers will recognize the symbol PHA as the instruction which will cause the 6502 to push the accumulator. PHA, $48, and even 01001000, to some extent, are translations from the machine’s language into a language that humans can understand more easily. We would like to be able to communicate to the computer in symbols like PHA; but if the machine is to understand us, we need a language translator to translate these symbols into machine language. The Debug Mode of Atari’s Editor/ Assembler cartridge, for example, can be used to translate the symbols $48 and PHA to the ones and zeros that the machine understands. The debugger can also translate the machine’s ones and zeros to $48 and PHA. The assembler part of the Editor/ Assembler cartridge can be used to translate entire groups of symbols like PHA to machine code . Assemblers An assembler – for example, the one contained in the Assembler/Editor cartridge – is a program which is used to translate symbols that a human can easily understand into the ones and zeros that the machine can understand. In order for the assembler to know what we want it to do, we must communicate with it by using a set of symbols arranged according to a set of rules. The assembler is a translator, and the language it understands is 6502 assembly language. The purpose of 6502 assembly language is to aid program authors in writing machine language code . The designers of the 6502 assembly language created a set of symbols and rules that matches 6502 machine language as closely as possible. This means that the assembler retains
One disadvantages of machine language. Por instance, the process of adding two large numbers takes dozens of instructions in 6502 machine language. If human programmers had to code those dozens of instructions in the ones and zeros of machine language, there would be very few human programmers. But the process of adding two large numbers in 6502 assembly language also takes dozens of instructions. The assembly language instructions are easier for a programmer to read and remember, but they still have a one-to-one correspondence with the dozens of machine language instructions. The programming is easier, but the process remains the same. High Level Languages High level languages, like Atari BASIC, Atari PILOT, and Atari Pascal, are simpler for people to use because they more closely approximate human speech and thought patterns. However, the computer still understands only machine language. So the high level languages, while seeming simple to their users, are really much more complex in their internal operations than assembly language. Each high level language is designed to meet the specific need of some group of people. Atari Pascal is designed to implement the concept of structured programming. Atari PILOT is designed as a teaching tool. Atari BASIC is designed to serve both the needs of the novice who is just learning to program a computer and the needs of the expert programmer who is writing a sophisticated application program, but wants the program to be accessible to a large number of users. Each of these languages uses a different set of symbols and symbol-combining rules. But all these language translators were themselves written in assembly language. Language Translation Methods There are two different methods of performing language translation – compilation and interpretation. Languages which translate via interpretation are called interpreters. Languages which translate via compilation are called compilers. Interpreters examine the program source text and simulate the operations desired. Compilers translate the program source text into machine language for direct machine execution.
One The compilation method tends to produce faster, more efficient programs than does the interpretation method. However, the interpretation method can make programming easier. Problems with the Compiler Method The compiler user first creates a program source file on a disk, using a text editing program. Then the compiler carefully examines the source program text and generates the machine language as required . Finally, the machine language code is loaded and executed. While this three-step process sounds fairly simple, it has several serious” gotchas.” Language translators are very particular about their symbols and symbol-combining rules. If a symbol is misspelled, if the wrong symbol is used, or if the symbol is not in exactly the right place, the language translator will reject it. Since a compiler examines the entire program in one gulp, one misplaced symbol can prevent the compiler from understanding any of the rest of the program – even though the rest of the program does not violate any rules! The result is that the user often has to make several trips between the text editor and the compiler before the compiler successfully generates a machine language program. But this does not guarantee that the program will work. If the programmer is very good or very lucky, the program will execute perfectly the very first time. Usually, however, the user must debug the program. This nearly always involves changing the source program, usually many times. Each change in the source program sends the user back to step one: after the text editor changes the program, the compiler still has to agree that the changes are valid, and then the machine code version must be tested again. This process can be repeated dozens of times if the program is very complex. Faster Programming or Faster Programs? The interpretation method of language translation avoids many of these problems. Instead of translating the source code into machine language during a separate compiling step, the interpreter does all the translation while the program is running. This means that whenever you want to test the program you’re writing, you merely have to tell the interpreter to run it. If things don’t work right, stop the program, make a few changes, and run the program again at once. 4 Chapter One You must pay a few penalties for the convenience of using the interpreter’s interactive process, but you can generally develop a complex program much more quickly than the compiler user can. However, an interpreter is similar to a compiler in that the source code fed to the interpreter must conform to the rules of the language. The difference between a compiler and an interpreter is that a compiler has to verify the symbols and symbol-combining rules only once – when the program is compiled. No evaluation goes on when the program is running. The interpreter, however, must verify the symbols and symbol-combining rules every time it attempts to run the program. If two identical programs are written, one for a compiler and one for an interpreter, the compiled program will generally execute at least ten to twenty times faster than the interpreted program. Pre-compiling Interpreter Atari BASIC has been incorrectly called an interpreter. It does have many of the advantages and features of an interpretive language translator, but it also has some of the useful features of a compiler. A more accurate term for Atari’s BASIC Language Translator is pre-compiling interpreter. Atari BASIC, like an interpreter, has a text editor built into it. When the user enters a source line, though, the line is not stored in text form, but is translated into an intermediate code, a set of symbols called tokens. The program is stored by the editor in token form as each program line is entered. Syntax and symbol errors are weeded out at that time. Then, when you run the program, these tokens are examined and their functions simulated; but because much of the evaluation has already been done, the execution of an Atari BASIC program is faster than that of a pure interpreter. Yet Atari BASIC’s program-building process is much simpler than that of a compiler. Atari BASIC has advantages over compilers and interpreters alike . With Atari BASIC, every time you enter a line it is verified for language correctness. You don’t have to wait until compilation; you don’t even have to wait until a test run. When you type RUN you already know there are no syntax errors in your program. 5 – – The programming language which has become the de facto standard for the Atari Home Computer is the Atari 8K BASIC Cartridge, known simply as Atari BASIC. It was designed to serve the programming needs of both the computer novice and the experienced programmer who is interested in developing sophisticated applications programs. In order to meet such a wide range of programming needs, Atari BASIC was designed with some unique features. In this chapter we will introduce the concepts of high level language translators and examine the design features of Atari BASIC that allow it to satisfy such a wide variety of needs. Language Translators Atari BASIC is what is known as a high level language translator. A language, as we ordinarily think of it, is a system for communication. Most languages are constructed around a set of symbols and a set of rules for combining those symbols. The English language is a good example. The symbols are the words you see on this page. The rules that dictate how to combine these words are the patterns of English grammar. Without these patterns, communication would be very difficult, if not impossible : Out sentence this believe, of make don’t this trying if sense you to! If we don’t use the proper symbols, the results are also disastrous: @twu2 yeggopt gjsiem, keorw? In order to use a computer, we must somehow communicate with it. The only language that our machine really understands is that strange but logical sequence of ones and zeros known as machine language. In the case of the Atari, this is known as 6502 machine language. When the 6502 central processing unit (CPU) “sees” the sequence 01001000 in just the right place according to its rules of syntax, it knows that it should push the current contents of 1 Chapter One the accumulator onto the CPU stack. (If you don’t know what an “accumulator” or a “CPU stack” is, don’t worry about it. For the discussion which follows, it is sufficient that you be aware of their existence.) Language translators are created to make it simpler for humans to communicate with computers. There are very few 6502 programmers, even among the most expert of them, who would recognize 01001000 as the push-the-accumulator instruction. There are more 6502 programmers, but still not very many, who would recognize the hexadecimal form of 01001000, $48, as the push-the-accumulator instruction. However, most, if not all, 6502 programmers will recognize the symbol PHA as the instruction which will cause the 6502 to push the accumulator. PHA, $48, and even 01001000, to some extent, are translations from the machine’s language into a language that humans can understand more easily. We would like to be able to communicate to the computer in symbols like PHA; but if the machine is to understand us, we need a language translator to translate these symbols into machine language. The Debug Mode of Atari’s Editor/ Assembler cartridge, for example, can be used to translate the symbols $48 and PHA to the ones and zeros that the machine understands. The debugger can also translate the machine’s ones and zeros to $48 and PHA. The assembler part of the Editor/ Assembler cartridge can be used to translate entire groups of symbols like PHA to machine code . Assemblers An assembler – for example, the one contained in the Assembler/Editor cartridge – is a program which is used to translate symbols that a human can easily understand into the ones and zeros that the machine can understand. In order for the assembler to know what we want it to do, we must communicate with it by using a set of symbols arranged according to a set of rules. The assembler is a translator, and the language it understands is 6502 assembly language. The purpose of 6502 assembly language is to aid program authors in writing machine language code . The designers of the 6502 assembly language created a set of symbols and rules that matches 6502 machine language as closely as possible.
One disadvantages of machine language. Por instance, the process of adding two large numbers takes dozens of instructions in 6502 machine language. If human programmers had to code those dozens of instructions in the ones and zeros of machine language, there would be very few human programmers. But the process of adding two large numbers in 6502 assembly language also takes dozens of instructions. The assembly language instructions are easier for a programmer to read and remember, but they still have a one-to-one correspondence with the dozens of machine language instructions. The programming is easier, but the process remains the same. High Level Languages High level languages, like Atari BASIC, Atari PILOT, and Atari Pascal, are simpler for people to use because they more closely approximate human speech and thought patterns. However, the computer still understands only machine language. So the high level languages, while seeming simple to their users, are really much more complex in their internal operations than assembly language. Each high level language is designed to meet the specific need of some group of people. Atari Pascal is designed to implement the concept of structured programming. Atari PILOT is designed as a teaching tool. Atari BASIC is designed to serve both the needs of the novice who is just learning to program a computer and the needs of the expert programmer who is writing a sophisticated application program, but wants the program to be accessible to a large number of users. Each of these languages uses a different set of symbols and symbol-combining rules. But all these language translators were themselves written in assembly language. Language Translation Methods There are two different methods of performing language translation – compilation and interpretation. Languages which translate via interpretation are called interpreters. Languages which translate via compilation are called compilers. Interpreters examine the program source text and simulate the operations desired. Compilers translate the program source text into machine language for direct machine execution.
The compilation method tends to produce faster, more efficient programs than does the interpretation method. However, the interpretation method can make programming easier. Problems with the Compiler Method The compiler user first creates a program source file on a disk, using a text editing program. Then the compiler carefully examines the source program text and generates the machine language as required . Finally, the machine language code is loaded and executed. While this three-step process sounds fairly simple, it has several serious” gotchas.” Language translators are very particular about their symbols and symbol-combining rules. If a symbol is misspelled, if the wrong symbol is used, or if the symbol is not in exactly the right place, the language translator will reject it. Since a compiler examines the entire program in one gulp, one misplaced symbol can prevent the compiler from understanding any of the rest of the program – even though the rest of the program does not violate any rules! The result is that the user often has to make several trips between the text editor and the compiler before the compiler successfully generates a machine language program. But this does not guarantee that the program will work. If the programmer is very good or very lucky, the program will execute perfectly the very first time. Usually, however, the user must debug the program. This nearly always involves changing the source program, usually many times. Each change in the source program sends the user back to step one: after the text editor changes the program, the compiler still has to agree that the changes are valid, and then the machine code version must be tested again. This process can be repeated dozens of times if the program is very complex. Faster Programming or Faster Programs?
The interpretation method of language translation avoids many of these problems. Instead of translating the source code into machine language during a separate compiling step, the interpreter does all the translation while the program is running. This means that whenever you want to test the program you’re writing, you merely have to tell the interpreter to run it. If things don’t work right, stop the program, make a few changes, and run the program again at once. The interpreter, however, must verify the symbols and symbol-combining rules every time it attempts to run the program. If two identical programs are written, one for a compiler and one for an interpreter, the compiled program will generally execute at least ten to twenty times faster than the interpreted program. Pre-compiling Interpreter Atari BASIC has been incorrectly called an interpreter. It does have many of the advantages and features of an interpretive language translator, but it also has some of the useful features of a compiler. A more accurate term for Atari’s BASIC Language Translator is pre-compiling interpreter.
Atari BASIC, like an interpreter, has a text editor built into it. When the user enters a source line, though, the line is not stored in text form, but is translated into an intermediate code, a set of symbols called tokens. The program is stored by the editor in token form as each program line is entered. Syntax and symbol errors are weeded out at that time. Then, when you run the program, these tokens are examined and their functions simulated; but because much of the evaluation has already been done, the execution of an Atari BASIC program is faster than that of a pure interpreter. Yet Atari BASIC’s program-building process is much simpler than that of a compiler. Atari BASIC has advantages over compilers and interpreters alike . With Atari BASIC, every time you enter a line it is verified for language correctness. You don’t have to wait until compilation; you don’t even have to wait until a test run. When you type RUN you already know there are no syntax errors in your program.
https://ia601407.us.archive.org/31/items/ataribooks-the-atari-basic-source-book/theataribasicsourcebook.pdf
References:

https://www.atariarchives.org/dere/chapt10.php

https://www.atari800xl.eu/docs/kb/kb-software-0005-atari-basic-overview.html

https://ia601407.us.archive.org/31/items/ataribooks-the-atari-basic-source-book/theataribasicsourcebook.pdf

The post Write up on Tech Geek History -Basic Programming appeared first on DayDreamin’ Comics.

1.2 Functionality
Streaming
A station is set by specifying an artist or song, or a combination of multiple items of any kind in a single station. Listeners can tune into established genre stations, other users’ stations or create their own stations based on their musical interests.[21] Each track played can be responded to with favorable (thumbs up) or unfavorable (thumbs down) buttons, which determine if it should be played, and if similarly classified songs should be played in the station. A second negative response to the same artist will ban that artist from the selected station unless the user has marked the artist positively on another occasion or if that artist is listed under the station’s variety. No response is applicable to musical attributes or to albums. An unfavorable response immediately stops play of the track. Clicking the thumbs down or skipping to the next song too many times in a row will result in a short ban of skips. Pandora also utilizes short advertisements between every couple of songs.
A menu is provided with options, such as “I’m tired of this song” (allowing a user to remove a song from the station temporarily, which counts as a skip), “Why was this song selected?” (allowing users to learn more about the composition of each song), “Move song to another station,” “New station,” and “Bookmark.” A “Buy” button is located at the top of each song block. From there, listeners can click on links to purchase the song from iTunes or Amazon.
There is a setting in each member’s account allowing the user to censor songs with explicit lyrics. The censoring option applies exclusively to song versions from albums with a Parental Advisory label, as other songs with censored versions will have that version played. An example is the song Jet Airliner by the Steve Miller Band, which had one word censored for radio play. With explicit lyrics off, that version will play, because the album did not have a PA label.
While listening, users are offered the ability to buy the songs or albums at various online retailers.[21] More than 450 musical attributes are considered when selecting the next song. These 450 attributes are combined into larger groups called focus traits. There are 2,000 focus traits. Examples of these are rhythm syncopation, key tonality, vocal harmonies and displayed instrumental proficiency.
The service has two subscription plans: a free subscription supported by advertisements, and a fee-based subscription without advertisements. There are advertisements in Pandora Mobile for mobile phones and in the Pandora computer appliance. In October 2014, less than 5 percent of active listeners were paying subscribers.[22] At the time of Pandora’s IPO in 2011, Pandora had 800,000 tracks from 80,000 artists in its library and 80 million users.[23] By November 2014, Pandora had approximately doubled its library size, topping 1.5 million songs.[24] As of end of mid-year 2018, Pandora had 71.4 million active users.[25]
In September 2016, Pandora announced additional features and subscription options, including a mid-level subscription service known as Pandora Plus that offers advertisement-free streaming, offline playback support using a prediction mechanism and more skips and replays. Users of the free advertisements-included service also were provided more skips and replays in exchange for watching an advertisement. Pandora also announced the launch of an on-demand service similar to competitors such as Apple Music and Spotify.[26][27]
On March 13, 2017, Pandora launched Pandora Premium, a new service allowing users to listen to and create playlists of individual songs on demand. Pandora’s suggestions engine suggests and recommends songs and albums, as well as generate playlists based on similar songs. Pandora also emphasized a use of machine learning and manual curation, and that it had filtered “karaoke tracks, knock-off covers and pet sounds (but not Pet Sounds) that slow down other services” from its library
1.3 Technical Aspects of Pandora

What is the Music Genome Project?
Inspired by the Human Genome Project of the 1990s and early 2000s, the Music Genome Project (MGP) was conceived by Pandora founder Tim Westergren to catalog the fundamental characteristics of the vast body of recorded music. The goal of this ambitious project was to allow music lovers to discover music based on inherent musical qualities, rather than sales data or industry-backed marketing. The Music Genome Project provides a detailed analysis of millions of songs, describing features of harmony, rhythm, melody, vocals, instrumentation, lyrics, and more. This data powers our best-in-class recommendation algorithms. Thanks to the rigorous and detailed music analysis of the Music Genome Project, none of our competitors can come close to the depth of our content understanding.

When analyzing a song, we often start with the genre, choosing from one or more of the 1300+ subgenres we have developed in our comprehensive genre taxonomy. Since many songs fit into more than one main genre, or borrow influences from a variety of genres, our nuanced analysis process allows us to indicate multiple genres and influences. Training is an essential ingredient for the Music Analyst team. In addition to extensive new hire training, ongoing training is required for maintaining broad genre knowledge, and for staying on top of the latest trends in music.

The level of depth and detail that goes into tagging a single song is unmatched anywhere in the streaming music universe. Pandora kind of analysis across millions of songs, which we then leverage to further our content knowledge across tens of millions more songs that make up our full catalog. Our data science team has used this massive treasure-trove of data to create the best music recommendation systems in the world, armed with the most comprehensive and complete content understanding database available anywhere. We believe that the next song matters, and that is why we work hard to make our streaming service the best in the world. I hope this helps explain why when that next song comes on your Pandora station, the recommendation we provide is the absolute best available

MGP2 – What’s Next for the Music Genome Project
Here at Pandora, we have recently completely redesigned the way we analyze music for the Music Genome Project, with a new system we call MGP2. We’ve developed a collection of new taxonomies that we use to describe songs, and a new, text-based tagging system that allows us to annotate music much more accurately and completely. This new way of annotating has improved all of our downstream systems and led to important improvements in the data science, machine learning, and content understanding that make our recommendation systems the best in the world.

What is MGP2?

When the Music Genome Project first began over 20 years ago, music analysis was done on pencil and paper, with analysts manually ripping CDs (remember those?) into the ingestion systems.
Music Analysts analyzing music in the early days of PandoraThe Music Genome Project Interface was soon developed, consisting of a series of “genes” that needed to be scored on a ten-point scale. This system enabled us to gather a massive amount of uniform data on millions of songs. However, as the years went by and music evolved, the original fixed set of genes could not keep up. As the tech stack aged, making changes to the system proved too costly and impractical. In the rapidly changing and increasingly genre-agnostic world of modern music, we needed a more fluid and flexible way to analyze songs.

Enter MGP2. This semantic, tag-based system lets us listen to songs and then add tags from a set of taxonomies. These taxonomies include:
• Genre
• Musicology
• Instrumentation
• Vocals
• Lyrics
• Mood
• Overall

Having fluid and dynamic control over these taxonomies allows us to add or adjust things as needed. It also turns out that these tags are much easier for humans to interpret, and also easier for machine learning models to use as inputs.

Pandora wrote thousands of translations, essentially a set of rules, to convert the numeric scores of the 2.2 million songs we analyzed in our old system into the text-based tags we created for MGP2. Once our science team updated our machine-learning models to use these tags as inputs, we saw immediate improvements in the scale and accuracy of all downstream systems, including predictions, recommendations, track grouping, and more. These models allow us to leverage the information from the 2.2 million songs we have analyzed onto the rest of the tens of millions of songs in our massive complete catalog. You can read more about the groundbreaking work they have published.

https://community.pandora.com/t5/Community-Blog/What-is-the-Music-Genome-Project/ba-p/116426

The Pandora algorithm uses these “genes” to affiliate songs on users’ stations, drawing on the user’s history and the collective history of all Pandora users. Although the relations that filiate certain songs and genres are fairly clear to Pandora users, the MGP’s genomic language and taxonomy may or may not be apparent. In keeping with the highly individualized discourse, most Pandora advertising emphasizes how the user’s individual history determines the songs on their stations.:

Pandora
While there doesn’t seem to be much word on how Spotify’s biggest competitor is approaching Artificial Intelligence, Pandora is another platform using AI to suggest music to listeners. In fact Pandora started life as the Music Genome Project, which was intended as a way to categorise music. To sort all of this music, CEO Tim Westergren and his team listen to the songs and manually assign them characteristics based on musical elements within the track. This means that for any given song, a list of other songs with similar attributes can be created. The whole concept behind it being that if someone enjoys one song, then they’ll enjoy others which share its attributes. As a way of demonstrating this in action, Pandora Radio was built, which can be accessed either through a web browser or through the dedicated mobile app. The service essentially gives users personalized radio stations aiming to have a balance of familiar and new music.
Pandora Radio makes use of a machine learning algorithm to put the Music Genome Project into practice. By using the attributes assigned to the songs alongside reactions from the listener (either a thumbs up or a thumbs down), the service is able to better decide what songs and artists to play or avoid playing.
https://futuresonic.io/discussion/ai-in-music-streaming/#:~:text=While%20there%20doesn’t%20seem,Writing%20Music%20With%20AI
Genomic Searches. Perhaps the most powerful search approach, and the one that engages students in the novice-to-expert transition, is the search based upon genomic similarity. As we think toward the future when the Genome will contain a wide range of multimedia assets from different engineering disciplines, genomic search tools become a way to illustrate the connections between seemingly disparate and unrelated problems. The collection of traits describing assets in the genome spans an n−dimensional space, and this genomic search amounts to a high-order nearest-neighbor search along the lines of Pandora’s search algorithm
The output of this search is the set of multimedia assets that are genetically related; that is, they are related based upon some underlying features defined by the controlled vocabulary of the ontology. Genetic similarity is based not primarily upon a single gene or tag, as in keyword or facet searchers, but rather on a collection of genes that are, in the aggregate, expressed in each of the related multimedia files.
Keyword and facet searches expose explicit similarities between multimedia assets (for instance, both keyword and facet searches will present multimedia assets in the same application area or that have the same underlying mathematics). However, the genomic search finds genetic near-neighbors wherever it can find them–including neighbors whose relationships are not explicitly clear..

So the Music Genome is a collection of digital assets (the songs) tagged with highly granular, descriptive attributes (the genes), and organized into a searchable database. The result is Pandora–the Internet radio station that allows users to probe the Music Genome and create playlists based upon keyword searches. Pandora interrogates the Music Genome to create a playlist of songs that are genomically related – the songs are close neighbors in the genome. Songs are not arranged by genre, or by era, or by band geographic origin, or by sales, or by any other coarse metric or hierarchical relationship. Rather, songs in the playlist are presented based upon their genomic similarity, based upon shared attributes.

Initial-development-of-the-engineering-genome-project-an-engineering-ontology-with-multimedia-resources-for-teaching-and-learning-engineering-mechanics.pdf nitial-development-of-the-engineering-genome-project-an-engineering-ontology-with-multimedia-resources-for-teaching-and-learning-engineering-mechanics.pdf

References:

Initial-development-of-the-engineering-genome-project-an-engineering-ontology-with-multimedia-resources-for-teaching-and-learning-engineering-mechanics.pdf nitial-development-of-the-engineering-genome-project-an-engineering-ontology-with-multimedia-resources-for-teaching-and-learning-engineering-mechanics.pdf
https://futuresonic.io/discussion/ai-in-music-streaming/#:~:text=While%20there%20doesn’t%20seem,Writing%20Music%20With%20AI
https://futuresonic.io/discussion/ai-in-music-streaming/#:~:text=While%20there%20doesn’t%20seem,Writing%20Music%20With%20AI

https://community.pandora.com/t5/Community-Blog/What-is-the-Music-Genome-Project/ba-p/116426

The post Write up on Tech Geek History: Pandora Radio Station appeared first on DayDreamin’ Comics.