Nicholas A Sano Fall 2011 Opus
My journey into Data Structures, HPC1 and System programing Unix/Linux
23 pastly white boy who has lived in the lair for a wounder full 2 previous semesters. With the watch full eyes of ceiling cat and his new apperentice Long cat as my guides, I hope to do more then ever before and get what I need done done. I will not be having no other locations for classes other then Lair in the BDC. unless its october then i will have two wellness classes which these classes will most likely suffer a bit.
How many Lair creatures dose it take to make a video cam move in a room unassisted by human hands
i did some research to find the hardware needed isn't hard to find but the programing required is almost nonexistent
you can not call a pointer before you have made it pointie and set the pointer to the pointie
Today is the first Friday of the first week of my 5th semester at CCC
this was the first day of week two
this was the 2nd day in the 3rd week when i got to sit down and type this so bare with it im a bit tired and grouchy i have to move my shit out of one house to another for some family and personal reason which i didn't want to do.
]
Fun Facts about the lair with no terminology or reason just for fun.
int main() {
int *i; int s[]; int i = s[i];
}
int main() {
int *i; int *h; int s[]; int *i=s[i]' int *h->*i
}
you'll notice that u have top as a process but your programs you have open are also processes but then notice that top is a command and not a program.
the current objective of the course is to get us to understand how pointers work how to implement Structures and how to use linked lists
the method I will be using to tell if I'm making progress is that for most of these early implementations I will be using them to do other assignments and if and when I understand enough to write one from near scratch which wont be for a while till then i will measure my results and record them as submitted assignments
I'm not sure what this means but so far i have been able to manipulated Characters and integers fairly well using some basic search algorithms how ever I'm finding that trying to take in command line arguments is proving and showing my apparent weak understanding of some basic fundamentals of C and C++ programing
Thew Results i have been getting and the out put is correct for most part and i been getting positive reviews but not nearly where i think i should be and I'm am failing and falling behind in the logical and understanding of what is actuality happening.
At the moment I'm not quite sure what i am attempting to do in system programing but if i could tie this in with my major HPC1 project i would probably see a better reason why to read the book (i“ve read the first 2 chapters)
the method of measure i will be using is the book and the experiments i will attempt currently no experiments or projects are being done by me for this class
Unfortunately as of Tuesday September 27,2011 i have neglected this course do to my focus on HPC1 Discrete math and Data Structures hwo ever i am working on an experimental idea that i will try either Thursday afternoon or Friday morning
Reflect upon your results of the measurement to ascertain your achievement of the particular course objective.
the objective in this class is to broaden are field of knowledge and use of Linux UNIX environments to better serve are future employers where ever and whom ever they may be are selfs or others.
the method i will base my results on is the variety of projects i do and how i can improve upon the concept
Currently my Motion Room tracks cam is a research state awaiting approval to move to the prototype stage which i have no clue how to attempt Currently my Lair power usage project is on going and fairly straight forward i am on the second week of testing will be testing new systems next week
most results are promising but there are minor concerns by myself and my instructor as to the actuality software implementation for the Motion cam system and as well as the degree of power usage there is in the lab may be more then expected.
What if i used a void pointer to point to a int then to a char with the same pointer in a single program.
Double and single linked list from Data class
I believe if u did this it would solve the problem of initialization your pointer to a certain variable type.
The reason i believe this s that void is a undetermined variable type which when pointed to one variable type to another should change with it.
I'm going to make a simple program and run it to point and print out each variable type data using a void pointer
the code Dose not let you dereference a void as a pointer
Based on the data collected:
if u are to over load the void pointer u might be able to get it to point to any variable type u want with out much problem and with very little repercussion do to the fact that it is defined as a empty variable type able to manipulate other variable types with out much harm. How ever from the conclusion I've witness and hand programed is that void by itself with out over loading it will not point to other variable types at all.
What is the question you'd like to pose for experimentation? State it here.
Collect information and resources (such as URLs of web resources), and comment on knowledge obtained that you think will provide useful background information to aid in performing the experiment.
Based on what you've read with respect to your original posed question, what do you think will be the result of your experiment (ie an educated guess based on the facts known). This is done before actually performing the experiment.
State your rationale.
How are you going to test your hypothesis? What is the structure of your experiment?
Perform your experiment, and collect/document the results here.
Based on the data collected:
What can you ascertain based on the experiment performed and data collected? Document your findings here; make a statement as to any discoveries you've made.
the qeustion is at what rate can a single process be performed using multiple terminals and the same process or command
past experiences have seen many different findings and one we recently noticed was the use of a xtv terminal screen to share sight of a single persons terminal.
based on what I've seen and done in the past with a small program or command running once and not continuously it will not be as difficult or as one that continues and updates periodically.
when Matt Haas first started to use the XTV environment to show us what he was doing on his terminal the delay and relay timer was set as fast as it could go and with about 10-13 people running it as is started to take up close to 90% of the CPU power on the servers and the delay times were closing in on 10 seconds per person.
I'm going to use Matt's XTV test to prove the bases that a constantly running program or command is more taxing then a simple quick command by getting people on Friday about 7 or more to run the same command line command of either top or who is less taxing then the XTV program
Perform your experiment, and collect/document the results here.
Based on the data collected:
What can you ascertain based on the experiment performed and data collected? Document your findings here; make a statement as to any discoveries you've made.
i can not recall what i did last week other then making the mistake of inheritance in a double link list manipulation by utilizing the possible code syntax as (this)start→(that)start=(this)start→(that)start→next
Monday-Absent Tuesday-Absent Wednesday-Absent Thursday-start second part of opus and finished double link list library Friday-continued work on opus, set up a new station for testing for HPC1 project, continued working on stacks and queues
Top refers to the first piece of a FILO Data Struck much like in a Stack
#include <stdio.h> int main() { return(0); }
Overflow condition only occurs i believe with an array based Stacks and Queues to do there finite size of usable Data Space.
Underflow condition is a common error with using stacks and Queues with out properly filling in either the data in the array or node structure for at least one element so when you go to look at the first chunk of data there isn't one so you end up with a Underflow Condition.
/* * Sample code block */ #include <stdio.h> int main() { return(0); }
LIFO refers to a last in first out Data Structure which can be be best represent by a Stack the idea of last in first out can be also compared to much of the United States Instructors system where the longer your there at one place the more likely u will keep your job even if your piss poor at it (not naming names) but there are those of them out there.
FIFO refers to first in first out Data Structure which can be represented by a Queue, the Idea of Queue are common many of use experience Queues on a daily bases in one way or another. A good example of a Queue would be a grocers check out line or a line for a sporting or even the movie theater ticket line the first there is the first served and the first one out of the line/Queue.
Queues much like stacks are used to order data and for reference quickly there are some times more efficient and more effective ways to do this but often times Queues are more practical for what the implementation is for, Such as if u wish for a FIFO Data Structure in stead of a double link list or a stack Queues are much more handy then rewriting programs or software to reference parts in a different order then what was initially intended for example when a company starts to take either take sale distributions either by volume or my name of person and i would be pissed if i went to pre-order a game in a high volume market area and not be able to get a reserve copy that i ordered before like a Joe Shmoe off the street got his before me with/out a pre-order coupon, or like when a concert or early viewing of a movie or a sport event and your first on the waiting list but some one goes to the ticket booth and buy the ticket meant for u
#include <stdio.h> int main() { return(0); }
Enqueuing is how to get the Queue started and place the first chunk of data into it all others fall after/behind, and Enqueuing is how u fill nt just the first part of data into a queue but every other part as well. think of it as like a first come first serve bases.
Dequeuing is the process in which after a enqueue occurs can be used to retrieve the data that was set in but how ever it only takes the first segment of data in the Queue any other then the first other wise it would be a considered a Doublelinklist modifier.
#include <stdio.h> int main() { return(0); }
overrun condition is a over run of queue line usually only happens when the Queue has been established and wont or isn't willing to take nay new data and in effect when you try to place it into the queue it just falls to the floor flailing its arms gasping for air. (using Enqueuing)
a Underrun condition is a lack of data in the queue while using the Dequeue when there is no data to retrieve. (using Dequeue)
definition: the binary tree is a sorted structure consisting of nodes Rules: No duplication nodes(aka this is not a rule i cant happen if it dose your code is busted) greater node take priority(the quintessential greater node will always take priority) there can be no more then two branches for a BINARY TREE Other uses for binary trees: algebraic notation in the forms of prefix/infix/postfix
Example of Algebraic notation in a Binary Tree Structure
(*)
/ \
(/) (+)
/ \ / \
(6) (2)(1) (2)
Computational complexity is the statement of how much of a resource or how many resources will have to be used to solve a algorithm such as saying how many operations are in the expression of 6/2(1+2) the answer is 4 (parenthesis multiplication division addition)
the use of algorithm in an already established binary tree to find a given parameter if it doesn't exist it adds it or it returns its location.
Identification and definition of the chosen keyword.
If you wish to aid your definition with a code sample, you can do so by using a wiki code block, an example follows:
/* * Sample code block */ #include <stdio.h> int main() { return(0); }
Identification and definition of the chosen keyword.
If you want to demonstrate something on the command-line, you can do so as follows:
lab46:~$ cd src lab46:~/src$ gcc -o hello hello.c lab46:~/src$ ./hello Hello, World! lab46:~/src$
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you wish to aid your definition with a code sample, you can do so by using a wiki code block, an example follows:
/* * Sample code block */ #include <stdio.h> int main() { return(0); }
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you want to demonstrate something on the command-line, you can do so as follows:
lab46:~$ cd src lab46:~/src$ gcc -o hello hello.c lab46:~/src$ ./hello Hello, World! lab46:~/src$
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you wish to aid your definition with a code sample, you can do so by using a wiki code block, an example follows:
/* * Sample code block */ #include <stdio.h> int main() { return(0); }
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you want to demonstrate something on the command-line, you can do so as follows:
lab46:~$ cd src lab46:~/src$ gcc -o hello hello.c lab46:~/src$ ./hello Hello, World! lab46:~/src$
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you wish to aid your definition with a code sample, you can do so by using a wiki code block, an example follows:
/* * Sample code block */ #include <stdio.h> int main() { return(0); }
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you want to demonstrate something on the command-line, you can do so as follows:
lab46:~$ cd src lab46:~/src$ gcc -o hello hello.c lab46:~/src$ ./hello Hello, World! lab46:~/src$
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you wish to aid your definition with a code sample, you can do so by using a wiki code block, an example follows:
/* * Sample code block */ #include <stdio.h> int main() { return(0); }
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you want to demonstrate something on the command-line, you can do so as follows:
lab46:~$ cd src lab46:~/src$ gcc -o hello hello.c lab46:~/src$ ./hello Hello, World! lab46:~/src$
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you wish to aid your definition with a code sample, you can do so by using a wiki code block, an example follows:
/* * Sample code block */ #include <stdio.h> int main() { return(0); }
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you want to demonstrate something on the command-line, you can do so as follows:
lab46:~$ cd src lab46:~/src$ gcc -o hello hello.c lab46:~/src$ ./hello Hello, World! lab46:~/src$
there are 3 basic types of files. They are normal, special, and directories. File properties usually range from read, wright, and execute. usually you cant execute special files or directories. cant usually write special files. properties are read write and execute.
inodes are much like nodes of preallocated memory space as well as being a pointer to a full data stream telling if its bigger then the preallocated spot the inode acts as a pointer to link the data in a one continuous on broken data stream
Data Blocks are the large sections of inodes linked together used by the file system for organization.
a condition that the flow of electrical system or processes where by the output is unexpected.
is a uninterrupted and repetitive program that concurrently runs along other programs
a reference to a file with in another file for either a description or as a header for that file to run that way it dose.
is a form of input/output processing that permits another process to continue to be processed and then transmits the input or output requested or needed
parent processes usually starts by taking in inputs and spawns other processes or calls other processing systems to either find other answers or other outputs to solve the requested command or program logic
this is considered a type of coding method or a syntactical event that happens during a programs run time where parts of code are waiting for an input from a separate process or the users input.
EXP printf(“enter a number here: “\n); scanf(”%d”, &input);
where as scanf waits for the user to enter an input
this is a coding option that allows the programmer with in the run time of the program to spawn multiple processes with in the same processes using a stepping speed time method allowed on the hard ware some CPU do not allow this becuase it can end up in a hyper thread.
hyper threading is the method of process control that allows the hardware on the computer to assign multiple processes the same work space multiple times
buffering is the hardwares way of telling the user that the data required for the next sequence of events is being gathered and processed
trying to finish the stack and queue libraries
brute force and try to get it done together
was aiming to get them all done by the 31st but it looks like i might only get 2 libraries done
the analysis of what I've done is satisfactory considering my life problems and complications with staying on task in discrete.
the objective idea for a power legend reference for one semester electrical use in the lair is one that can be useful in determining radicals or an influx of pricing or power usage to determine if we are over or under budget
measure all lab stations in the lair including large student projects like the lair wall or multiple powered servers.
based on the data I'm collecting as of a price of 11cents per K/W hr im currently a little over 700 dollars for all front room student terminals and the 2 large servers in the room.
use stacks and queues to make a solitaire card game for system programing
method of doing it making a function to flip cards face up and down and using multiple manipulation of stacks and queues to run the loop to fill the field then use a stack and a queue in a continues fashion to run and be click able and usable by the user.
well this project I'm doing for system programing the solitaire game with Brian E not to be confused for Aninja. the measurement of progreess is steadily increasing due to the fact that i have my double link list done and i need to implement is the tack and queue libraries.
Fairly good considering Brian E is the only one actuality completely done with his stack and Queue libraries and i am nearing the end of mind after wards we would need to make a program to implement the game.
What is the question you'd like to pose for experimentation? State it here.
Collect information and resources (such as URLs of web resources), and comment on knowledge obtained that you think will provide useful background information to aid in performing the experiment.
Based on what you've read with respect to your original posed question, what do you think will be the result of your experiment (ie an educated guess based on the facts known). This is done before actually performing the experiment.
State your rationale.
How are you going to test your hypothesis? What is the structure of your experiment?
Perform your experiment, and collect/document the results here.
Based on the data collected:
What can you ascertain based on the experiment performed and data collected? Document your findings here; make a statement as to any discoveries you've made.
What is the question you'd like to pose for experimentation? State it here.
Collect information and resources (such as URLs of web resources), and comment on knowledge obtained that you think will provide useful background information to aid in performing the experiment.
Based on what you've read with respect to your original posed question, what do you think will be the result of your experiment (ie an educated guess based on the facts known). This is done before actually performing the experiment.
State your rationale.
How are you going to test your hypothesis? What is the structure of your experiment?
Perform your experiment, and collect/document the results here.
Based on the data collected:
What can you ascertain based on the experiment performed and data collected? Document your findings here; make a statement as to any discoveries you've made.
If you're doing an experiment instead of a retest, delete this section.
If you've opted to test the experiment of someone else, delete the experiment section and steps above; perform the following steps:
Whose existing experiment are you going to retest? Prove the URL, note the author, and restate their question.
Evaluate their resources and commentary. Answer the following questions:
State their experiment's hypothesis. Answer the following questions:
Follow the steps given to recreate the original experiment. Answer the following questions:
Publish the data you have gained from your performing of the experiment here.
Answer the following:
Answer the following:
Definition: Hash tables are used to reference the location of large chunks of related Data or info to the subject the Hash table its self represents.
Example:
Hash table count bases base2|base8|base10|base16
0 0 0 0
1 1 1 1
2 2 2
3 3 3
4 4 4
5 5 5
6 6 6
7 7 7
8 8
9 9
A
B
C
D
E
F
the act of insertion is just a basic way of say fill in a node structure with values of some kind
Example int main(Node *root,Node *next,Node *prev) {
Node *tmp;
int input;
printf("please enter a value to add to the binary tree: ");
scanf("%d", &input);
tmp=root;
while( input != -1)
{
if (tmp == NULL)
{
tmp=(Node *) malloc (sizeof(Node));
tmp->value=input;
}
else
{
if (input > tmp->value)
{
tmp=tmp->next;
if (tmp == NULL)
{
tmp=(Node *) malloc (sizeof(Node));
tmp->value=input;
tmp=root;
}
}
else
{
tmp=tmp->prev;
if (tmp == NULL)
{
tmp=(Node *) malloc (sizeof(Node));
tmp->value=input;
tmp=root;
}
}
}
}
removal of a node from a binary tree is difficult how ever a search function is not as difficult Definition Search in binary tree: transverse the tree by greater or less then comparison till you end up at your destination Definition removal in binary tree: “freeing” the node's selected value and removing the entire tree around to make sense with out losing and nodes that are still desired. Example
Node *tmp,*tmp2,*tmp3,*tmp4;
tmp=root;
int choice,flag=0;
while(input != -1)
{
if(input > tmp->value)
{
while(tmp->value < input)
{
tmp=tmp->next;
tmp4=tmp->next->next;
if(tmp->next->value == input)
{
printf("%d is the number your searching for, enter 1 to delete or 0 to skip deletion: \n", tmp->value);
scanf("%d", &flag);
tmp=tmp4->prev;
tmp2=tmp->prev;
if(flag == 1)
{
while(tmp2->prev->prev != NULL)
{
tmp3=tmp2->prev;
tmp2->prev=tmp3->next;
tmp3->prev=tmp->prev;
tmp3->next=tmp->next;
tmp4->prev=tmp3;
tmp->prev=tmp->next=NULL;
free(tmp);
}
}
}
}
}
definition: a sorting algorithm is a process with in a program that compares to a set standard or rules
Example the binary tree requires a algorithm to sort the numbers by greater than or less than and then keeps that comparison going till it finds a place to set the entered value
Definition: a selection statement is a basic algorthm that requires a true or flase answer in the binary environment or a greater to or less then for the natural environment.
Example: Natural selection and the food chain is a basic natural selection algorithm just as an if statement in comparison of two or more variables, or a while loop with a condition statement
Definition: a Graph by definition is a set or intersecting edges aka a system to compare or show information or data
Example:
the binary search tree is the best example of a greater then or less then graph and its simple to understand but difficult to implement.
these are equations that measure the practicality of algorithm based on its simplicity and complexity simple to read complex to implement.
definition: bubble sorting to my understanding is a swap in and out sort that will take one values or place and swap it with another to make corrections or to change a pattern if desired.
Definition: by definition insertion sort algorithms work by inserting a variable one at a time in a single D list or array.
Definition: Quick sorting is the method that when u take the average or a set number of varible list lengths and start sorting them by length not by relevance its going to run more quickly and smoothly.
Conceptually, a merge sort works as follows
1. If the list is of length 0 or 1, then it is already sorted. Otherwise: 2. Divide the unsorted list into two sublists of about half the size. 3. Sort each sublist recursively by re-applying the merge sort. 4. Merge the two sublists back into one sorted list.
Merge sort incorporates two main ideas to improve its runtime:
1. A small list will take fewer steps to sort than a large list. 2. Fewer steps are required to construct a sorted list from two sorted lists than from two unsorted lists. For example, you only have to traverse each list once if they're already sorted (see the merge function below for an example implementation).
ALL INFO ABOVE FOR DEFINITION IS BY WIKIEPIDIA
Identification and definition of the chosen keyword.
If you wish to aid your definition with a code sample, you can do so by using a wiki code block, an example follows:
/* * Sample code block */ #include <stdio.h> int main() { return(0); }
Identification and definition of the chosen keyword.
If you want to demonstrate something on the command-line, you can do so as follows:
lab46:~$ cd src lab46:~/src$ gcc -o hello hello.c lab46:~/src$ ./hello Hello, World! lab46:~/src$
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you wish to aid your definition with a code sample, you can do so by using a wiki code block, an example follows:
/* * Sample code block */ #include <stdio.h> int main() { return(0); }
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you want to demonstrate something on the command-line, you can do so as follows:
lab46:~$ cd src lab46:~/src$ gcc -o hello hello.c lab46:~/src$ ./hello Hello, World! lab46:~/src$
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you wish to aid your definition with a code sample, you can do so by using a wiki code block, an example follows:
/* * Sample code block */ #include <stdio.h> int main() { return(0); }
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you want to demonstrate something on the command-line, you can do so as follows:
lab46:~$ cd src lab46:~/src$ gcc -o hello hello.c lab46:~/src$ ./hello Hello, World! lab46:~/src$
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you wish to aid your definition with a code sample, you can do so by using a wiki code block, an example follows:
/* * Sample code block */ #include <stdio.h> int main() { return(0); }
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you want to demonstrate something on the command-line, you can do so as follows:
lab46:~$ cd src lab46:~/src$ gcc -o hello hello.c lab46:~/src$ ./hello Hello, World! lab46:~/src$
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you wish to aid your definition with a code sample, you can do so by using a wiki code block, an example follows:
/* * Sample code block */ #include <stdio.h> int main() { return(0); }
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you want to demonstrate something on the command-line, you can do so as follows:
lab46:~$ cd src lab46:~/src$ gcc -o hello hello.c lab46:~/src$ ./hello Hello, World! lab46:~/src$
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you wish to aid your definition with a code sample, you can do so by using a wiki code block, an example follows:
/* * Sample code block */ #include <stdio.h> int main() { return(0); }
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you want to demonstrate something on the command-line, you can do so as follows:
lab46:~$ cd src lab46:~/src$ gcc -o hello hello.c lab46:~/src$ ./hello Hello, World! lab46:~/src$
a server socket is a end point and access point to communicate bidirectional to a server for either for information or just Data it is monitored and limited by user access administrator access or a roots access in hopes of not causing to much chaos and problems usually a server sockets are used for lagre programs or an Internet protocol or a website(which this can be ran off a simple computer not a server)
a client socket is an end point where the data is either received or transmitted via an CLI request not an automated response like a server socket now there are some server sockets that require a CLI input or request but then it would be a server client system where you are managing your server and not automating it
a Unix Domain socket or IPC socket is an end point to where request either form a server socket or a client socket is orginized and some times processed and moved along to its destination or back to its transmission
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you want to demonstrate something on the command-line, you can do so as follows:
lab46:~$ cd src lab46:~/src$ gcc -o hello hello.c lab46:~/src$ ./hello Hello, World! lab46:~/src$
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you wish to aid your definition with a code sample, you can do so by using a wiki code block, an example follows:
/* * Sample code block */ #include <stdio.h> int main() { return(0); }
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you want to demonstrate something on the command-line, you can do so as follows:
lab46:~$ cd src lab46:~/src$ gcc -o hello hello.c lab46:~/src$ ./hello Hello, World! lab46:~/src$
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you wish to aid your definition with a code sample, you can do so by using a wiki code block, an example follows:
/* * Sample code block */ #include <stdio.h> int main() { return(0); }
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you want to demonstrate something on the command-line, you can do so as follows:
lab46:~$ cd src lab46:~/src$ gcc -o hello hello.c lab46:~/src$ ./hello Hello, World! lab46:~/src$
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you wish to aid your definition with a code sample, you can do so by using a wiki code block, an example follows:
/* * Sample code block */ #include <stdio.h> int main() { return(0); }
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you want to demonstrate something on the command-line, you can do so as follows:
lab46:~$ cd src lab46:~/src$ gcc -o hello hello.c lab46:~/src$ ./hello Hello, World! lab46:~/src$
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you wish to aid your definition with a code sample, you can do so by using a wiki code block, an example follows:
/* * Sample code block */ #include <stdio.h> int main() { return(0); }
Identification and definition of the chosen keyword. Substitute “keyword” with the actual keyword.
If you want to demonstrate something on the command-line, you can do so as follows:
lab46:~$ cd src lab46:~/src$ gcc -o hello hello.c lab46:~/src$ ./hello Hello, World! lab46:~/src$
State the course objective; define what that objective entails. this months objective was to finish the opus and to do the binary tree
State the method you will use for measuring successful academic/intellectual achievement of this objective. completion and ability to run is the to measure successfulness.
Follow your method and obtain a measurement. Document the results here. its complete and i have used it twice and runs correctly
Reflect upon your results of the measurement to ascertain your achievement of the particular course objective.
i did well
always able to im prove but i cant see one
more checks and more people to test it
yes to be tested by more people and more times proves the effectiveness
don't know of one and didn't alter anything
State the course objective; define what that objective entails. to finish the stuff
State the method you will use for measuring successful academic/intellectual achievement of this objective. if i get it done
Follow your method and obtain a measurement. Document the results here. still going
Reflect upon your results of the measurement to ascertain your achievement of the particular course objective.
doing well
always
breakdown instead of true or false
yes
maybe don't know
State the course objective; define what that objective entails.
State the method you will use for measuring successful academic/intellectual achievement of this objective.
Follow your method and obtain a measurement. Document the results here.
Reflect upon your results of the measurement to ascertain your achievement of the particular course objective.
What is the question you'd like to pose for experimentation? State it here.
Collect information and resources (such as URLs of web resources), and comment on knowledge obtained that you think will provide useful background information to aid in performing the experiment.
Based on what you've read with respect to your original posed question, what do you think will be the result of your experiment (ie an educated guess based on the facts known). This is done before actually performing the experiment.
State your rationale.
How are you going to test your hypothesis? What is the structure of your experiment?
Perform your experiment, and collect/document the results here.
Based on the data collected:
What can you ascertain based on the experiment performed and data collected? Document your findings here; make a statement as to any discoveries you've made.
What is the question you'd like to pose for experimentation? State it here.
Collect information and resources (such as URLs of web resources), and comment on knowledge obtained that you think will provide useful background information to aid in performing the experiment.
Based on what you've read with respect to your original posed question, what do you think will be the result of your experiment (ie an educated guess based on the facts known). This is done before actually performing the experiment.
State your rationale.
How are you going to test your hypothesis? What is the structure of your experiment?
Perform your experiment, and collect/document the results here.
Based on the data collected:
What can you ascertain based on the experiment performed and data collected? Document your findings here; make a statement as to any discoveries you've made.
If you're doing an experiment instead of a retest, delete this section.
If you've opted to test the experiment of someone else, delete the experiment section and steps above; perform the following steps:
Whose existing experiment are you going to retest? Prove the URL, note the author, and restate their question.
Evaluate their resources and commentary. Answer the following questions:
State their experiment's hypothesis. Answer the following questions:
Follow the steps given to recreate the original experiment. Answer the following questions:
Publish the data you have gained from your performing of the experiment here.
Answer the following:
Answer the following: