My OOP344 Blog

A Good 'typedef' reference

2010-09-14T22:09:00.001-04:00

http://en.wikipedia.org/wiki/Typedef

Review OOP344

2010-08-21T23:25:00.002-04:00

extern "C"{
include"hello.h"
}

The pre-processor substitutes each macro citation with the replacement text. The pre-processor recognizes three types of macros:

object-like macros
function-like macros
predefined macros

Efficiency and Flexibility

Function-like macros provide efficient and flexible solutions. They avoid the overhead of function calls and do not impose type constraints on the parameters in the macro definition.

Revew OOP244 - Derived Class

2010-07-26T09:42:00.003-04:00

The subject of an "is-a-kind-of" relationship is the derived class. The object is the base class.

Little notes

student.Person::display();

Derived Class with resource copy constructor, please refer here.

Revew OOP244 - Conversion Operators

2010-07-26T08:43:00.002-04:00

The form of a conversion operator declaration is

 operator dataType() const;

example: operator int() const;


In our case, the compiler fails to find an exact, promoted,
      or standard-conversion match for any argument-parameter pair,
      and searches the single argument constructors for a derived data
      type conversion match.  The compiler inserts the
      constructor code to convert 1234 to a
      Student and then calls the assignment
      operator that receives a Student as
      its right operand.  That is,
harry = 1234; // calls operator=(const Student& Student(1234))

If the Student(int) constructor were absent, the compiler could not convert 1234 to a Student and would reject the assignment expression. However, if our class declaration had a Student(long long) constructor, the compiler could convert 1234 to 1234LL, then convert 1234LL to a Student data type, and finally assign the right Student operand to the left Student operand.


To comprehend above please refer more detail

Revew OOP244 - Custom iostream Operators

2010-07-26T08:29:00.000-04:00

Revew OOP244 - deep copy

2010-07-26T08:08:00.002-04:00

In object-oriented programming, an object is not limited to the information stored in its own memory. An object can also access resources. A resource is information that is available to the object but is stored outside the object. The structure of such objects is described by classes with resources.

Resources

Resources include dynamic memory and files. These collections of information contain data that is stored outside the memory allocated to an object. An object keeps track of its resources through instance variables that hold the addresses of the resources. Such instance variables include

pointers to dynamic arrays in freestore memory
pointers to file structures
references

We call such instance variables resource instance variables.

To enable deep copying, we overwrite the compiler defaults for two member functions:

the copy constructor
the assignment operator

A copy constructor declaration takes the form

 Identifier ( const Identifier& );

Assignment Operator

The assignment operator is an operator that copies data from an existing object into an existing object. The compiler calls this operator whenever the compiler encounters an expression of the form

identifier = identifier where identifier is the name of an object.

The form of an assignment operator declaration is

Identifier& operator=(const Identifier&);

No Copies Allowed

In certain applications, it may be wise to avoid the making copies or assignments altogether. To prohibit the copying and the assigning of objects, we declare the copy constructor and the assignment operator as private members. For example,

class Student { int no; char* grade; Student(const Student& source); void operator=(const Student& source); public: Student(); Student(int, const char*); ~Student(); void display() const; };

Revew OOP244 - Operator +

2010-07-26T08:07:00.001-04:00

 Student operator+(const Student &student, char grade) {
    Student modified = student;
    modified += grade;      // calls += operator
    return modified;
}

Student operator+(char grade, const Student &student) {
    return student + grade; // calls operator+(const
                            //    Student&, char)
}

Revew OOP244 - friend & friend class

2010-07-26T08:01:00.003-04:00

friend type helper(...);
in .h file
friend int operator==(const Student&, const Student&);
in .cpp file
int operator==(const Student& lhs, const Student& rhs) {
    return lhs.no == rhs.no &&
           strcmp(lhs.grade, rhs.grade) == 0;
}

Friend Classes (Optional)

A class can grant access to its own private members to all of the member functions of another class. A class friendship declaration takes the form

friend class Identifier;

where Identifier is the name of the class that is to have private access privileges.

class student{

...

public:

...

friend class Administrator;

}

Revew OOP244 - Operators overload

2010-07-26T07:50:00.002-04:00

Candidates for Overloading

We may overload the following operators (amongst others):

post-fix/pre-fix (++ --)
assignment (= += -= *= /= %=)
unary arithmetic (+ -)
binary arithmetic (+ - * / %)
relational (== < > <= >= !=)
logical (&& || !)

We may NOT overload the following operators

the scope resolution operator (::)
the member selection operator (.)
the member selection through pointer to member operator (.*)
the ternary operator (?:)
the sizeof operator (sizeof)
the typeid operator (type())

Post-Fix Operators

Type operator++(int)  or  Type operator--(int)
The int type in the parameter list
      distinguishes the post-fix operator from its pre-fix
      counterpart.

 Student Student::operator++() {
    for (int i = 0; grade[i] != '\0'; i++)
        if (grade[i] == 'F') grade[i] = 'D';
        else if (grade[i] != 'A') grade[i]--;
    return *this;
}

Student Student::operator++(int) {
    Student s = *this;  // save the original
    ++(*this);          // call the pre-fix operator
    return s;           // return the original
}

Revew OOP244 -

2010-07-26T00:38:00.002-04:00

Manipulator	Effect
fixed	display floats in fixed-point format
scientific	display floats in floating-point format
left	left justify
right	right justify
flush	flush the output buffer
endl	send end of line and flush
setprecision(int)	set number of digits output
setfill(int)	set fill character
setbase(int)	set base for int output
setw(int)	set field width for next output only

call global function

2010-07-26T00:33:00.001-04:00

 display();   // calls member function from inside a member function
::display(); // calls global function from inside a member function

Revew OOP244 - Insufficient Memory

2010-07-26T00:26:00.002-04:00

include
Student* student = NULL;
student = new (nothrow) Student[n];
if (student == NULL)
cout << "Memory Allocation Failed" <<>
else {
...
}

Revew OOP244 - Dynamic Memory

2010-07-26T00:19:00.001-04:00

A program that the operating system has loaded into primary memory may obtain additional memory from the operating system at run-time. We refer to this additional memory as dynamic memory.

Variables and objects stored in dynamic memory can survive until the program terminates if necessary. Their lifetime only ends when the program explicitly deallocates their dynamic memory. Note that, unlike variables and objects in static memory, those in dynamic memory do not go of out scope at the closing brace of the block within which they have been defined.

Review OOP244 - Primitive types & Derived Types

2010-07-25T23:12:00.008-04:00

Both C and C++ predefine all of their primitive types. We cannot redefine these types or introduce new primitive types.
int,double,float,char

derived types
struct Type{
...
};

 struct Student {
  int no;          // student number
  char grade[14];  // grades
};

struct Student harry;

to access harry's student number, we write

harry.no;


to get address of harry's student number, we write

&harry.no;

//&harry.grade[0];

We retrieve the address of a non-array member using the address of operator (&)

&instance.member

Revew OOP244 - Array and Pointer

2010-07-25T22:09:00.010-04:00

y=NULL;
cout < < y; output is 0 double* address= NULL; y=*address; cout< < y; output is segementation fault

Tips on char* and char array

 char str[] = "This is OOP244";
char* s;

s = &str[8];              // points to the first 'O' in OOP244
cout << *(s + 3) << endl; // displays 244

Review OOP244 - Modular Programs

2010-07-25T21:50:00.005-04:00

3 concepts applies to designing classes
Encapsulation, Inheritance, Polymorphism

What Does Compiler Do?

the pre-processor inserts the contents of the header files into the implementation file for each module and substitutes all #define strings to create a single source file ready for compilation
the compiler properly compiles each pre-processed source file and create a binary file
the linker assembles the binary files for the application with the library binary files to form a single executable file

Summary

an application may be divided into a number of independent components: these components are called modules
a different module can be defined for each class in an application due to the encapsulated nature of the class
preparation of an executable file entails three separate stages: pre-processing, compilation and linking
each module consists of a header file and an implementation file and is pre-processed and compiled independently
a module's header file contains the declarations of the module's names without definitions or any executable statements
a module's implementation file contains the definitions of the module's functions
for compilation, a module's implementation file only needs to include the header files of those modules that contain declarations of the names referred to in the implementation file itself

swap is a common function name which be used in basic libraries

2010-07-25T12:20:00.001-04:00

try to avoid use it "swap" as function name

New Style Casts

2010-07-25T11:11:00.002-04:00

New Style Casts

The new style casts are both more specific and much easier to spot. Their syntax includes the letters _cast, which makes searching more straightforward. The casts are in template function form, where the variable or object to be cast is passed as the function argument and the destination type is passed as the template argument. There are four distinct categories of casts:

static cast
```
static_cast( minutes )
```
const cast
```
const_cast(&p)(Polygon is a class here)
```
re-interpret cast
Re-Interpret Cast

A re-interpret cast converts a value between unrelated data types such asinteger to pointer type, pointer to unrelated pointer type

For example,

 // Re-Interpret Cast
// reinterpret.cpp
// Nov 21 2005

#include 
using namespace std;

int main( ) {
    int* p;
    int x = 0x00ff00;

    p = reinterpret_cast( x );  // New Style Cast
    cout << hex << p << endl;

    return 0;
}

dynamic cast

shortcut to compile on matrix

2010-07-24T21:28:00.001-04:00

To compile in matrix, use: g++ yada.cpp yadoo.cpp -x c iof.c -lncurses If you have many cpp's, you may also do g++ *.cpp -x c iof.c -lncurses

keywords throw / try /catch and example of their usage

2010-07-24T19:18:00.003-04:00

 void divide(int a[], int i, int n, int divisor) {
 if(i <>= n)
     throw "Outside array bounds";
 else if(divisor == 0)
     throw divisor;
 else
     a[i] = i / divisor;
}

int main() {
 bool keepgoing = true;
 int a[MAX] = {1,2,3,4,5,6,7,8,9,10}, index,
     divisor;

 do {
     try {
         cout << "Index: ";             cin >> index;
         cout << "Divisor: ";             cin >> divisor;
         divide(a, index, MAX, divisor);
         cout << "a[index] = " << class="high">} catch(const char* msg) {
         cout << keepgoing =" false;" class="high">} catch(int value) {
         cout << "Zero divisor" << class="high">}
 } while (keepgoing);

 return 0;
}

       All of the code within the try
       block is executed repeatedly unless an exception is thrown by
       any of the statements within the block.  If an exception is
       thrown, any remaining code within the try block is skipped and the code in the first
       catch block that receives a type
       matching the type of the thrown exception is executed.  If
       an exception is thrown and no match is found at any point in the
       program, the program calls std::terminate(), which terminates
       execution.

what is dynamic_cast?

2010-07-24T17:17:00.002-04:00

 bool Box::operator==(const Shape& s) const {
  return hght == dynamic_cast(s).hght &&
         wdth == dynamic_cast(s).wdth &&
         dpth == dynamic_cast(s).dpth;
}

Answer:

The cast of the reference to a Shape to a reference to a Box is necessary to enable access to the size instance variables of the Box object. We call this a dynamic cast. Without this cast, the compiler would generate an error to the effect that the size variables are not members of the Shape class:

 bool Box::operator==(const Shape& s) const {
    return hght == s.hght && // ERROR hght is not a member of s
           wdth == s.wdth && // ERROR wdth is not a member of s
           dpth == s.dpth;   // ERROR dpth is not a member of s 
}
On the other hand, receiving a reference to a Box object directly would accept the definition

bool Box::operator==(const Box& s) const { // ERROR does not define
// == const Shape&
return hght == s.hght && wdth == s.wdth && dpth == s.dpth;
}

abstract class Pure Virtual Functions

2010-07-24T15:20:00.003-04:00

An abstract class identifies the properties that need to be defined through pure virtual functions. For instance, if a Shape has a volume, then the abstract Shape class would include a pure virtual function for volume.

The term interface refers to an abstract class that contains no data members.

and / or

A class that includes at least one pure virtual function is an abstract base class. (may contains data members on this situation)

Pure Virtual Functions

A pure virtual function is a virtual function that has form but no implementation. The declaration of a pure virtual function takes the form

 virtual type identifier(parameters) = 0;

2010-07-24T10:47:00.003-04:00

Virtual Inheritance

To avoid duplication of the instance of the base class, the Box and ColouredShape object can share the same Shape object.

// A Box
// Box.h
// Jun 9 2007

#include "Shape.h"

class Box : virtual public Shape {
 int hght;
 int wdth;
 int dpth;
protected:
 void displayDetails() const;
public:
 Box(const char* s, int h, int w, int d);
 virtual void display() const;
};

Read more details https://cs.senecac.on.ca/~btp300/pages/content/minhe.html

Diamond problem

From Wikipedia, the free encyclopedia

Jump to: navigation, search

A diamond class inheritance diagram.

In object-oriented programming languages with multiple inheritance and knowledge organization, the diamond problem is an ambiguity that arises when two classes B and C inherit from A, and class D inherits from both B and C. If a method in D calls a method defined in A (and does not override the method), and B and C have overridden that method differently, then from which class does it inherit: B, or C?

Please refer to http://en.wikipedia.org/wiki/Diamond_problem

2010-07-22T09:29:00.003-04:00

UNIX and Linux Scripts

The Unix environment variable $? holds the return value from the program that has just completed execution.

MS DOS

The MS-DOS environment variable %errorlevel% holds the return value from the program that has just completed execution.

2010-07-22T08:14:00.002-04:00

The macro NULL is defined in several system header files, including stddef.h and stdio.h.
It is good style to set every pointer that is not currently holding a valid address to NULL.

Odd Test

The & operator provides a simple way to check if an integral value is odd: that is, whether its least significant bit is 1.

 odd  = value & 1

odd has the value 1 if value is odd, 0 if value is even.

2010-07-21T23:01:00.004-04:00

Note that sizeof() takes a type, while sizeof takes a variable, object or expression. With some compilers, the two operators are interchangeable.

For normal usage, we may add the keyword auto (for automatic) to the definition

 auto int local = 2;

Since this is the default for any function parameter or any variable defined within a block, we seldom see this keyword in practice.

For very frequent usage, we add the keyword register to the definition

 register int local = 2;
static int local = 2;

External Linkage

A variable of static duration with external linkage can be shared by several modules. The compiler allocates memory for the variable in one module and the linker allows all modules access to that memory location. Each reference to the variable accesses the same memory location, regardless of the module from which the reference is made. To identify external linkage, we add the keyword extern to the declaration

extern int shared;

C Conversion Specifiers

The C language conversion specifiers for the int type used in calls to scanf() are

Specifier	Input Value	Argument	Default Conversion
%c	cc...c	char*	one or more characters
%d	[-\|+]dd...d	int*	signed decimal
%i	[-\|+][0[x]]dd...d	int*	signed integer
%u	[-\|+]dd...d	unsigned*	unsigned decimal
%o	[-\|+]dd...d	unsigned*	unsigned octal
%x	[-\|+][0x]dd...d	unsigned*	unsigned hexadecimal

2010-07-16T23:24:00.001-04:00

for myself remind

create an account on the silverhouse.com?
explorer the binary file format and operation in C++ to prepare for assignment

2010-07-12T11:03:00.000-04:00

what is bitsfield?

Linked List

2010-07-11T22:08:00.003-04:00

2 posted articles I googled them
http://www.fredosaurus.com/notes-cpp/ds-lists/list-ex1a.html it supports *head and *back pointer. which I'm perfer.
http://www.dreamincode.net/code/snippet82.htm this one easy and clean for the beginner.

To enable removeBack() method wihout using loop in linked list. I guess unless I put another attribute of a point* of node to point the previous node; otherwise it is an unsolved quest.

2010-06-30T09:35:00.002-04:00

computer stores number on one/two's complemental code method. true code, complemental code and one's complement code of unsigned number are all equel;
For example, 10 (decimal) are all 00001010；

But -10(decimal):
true code：10001010 ('+' is 0, '-' is 1）

complemental code：11110101 sign bit doesn't change, rest all of bits ~

two's complemental code：11110110 base on complemental code plus 1

2010-06-28T17:31:00.000-04:00

g++ ioframe_tester.cpp ioframe.cpp -x c iof.c -lncurses
compile c code under c++ compiler

need to write something down.

2010-06-27T00:14:00.003-04:00

1st, I need to write some important points down during learning.
2nd, to do
make file of the project, need a review of oop244.
new phase of the edit project

a nice place to review bit operation

2010-06-26T23:45:00.002-04:00

http://yujinjeong.wordpress.com/
one of my classmates did a well job on the bit operation, simply link to his blog as my reference

2010-06-07T21:46:00.002-04:00

50 rules to learn C++ Language. (I filed it to encourage myself during study C++)

MemCpy()

2010-06-07T19:46:00.001-04:00

inline void MemMoveBYTEHelp( char * pDest, char * pSrc, unsigned int iCount )
{
__asm{
mov edi, pDest;
mov esi, pSrc;
mov ecx, iCount;
rep movsb;
}
}

云风的《游戏编程感悟》一书曾提到这个，里面说，64KB的内存拷贝是快不过 memcpy 的，因为VC中，memcpy 并是当做一个函数来编译的，也就是说编程器会特别照顾 memcpy

2010-06-06T19:22:00.009-04:00

     dumpHexa(&x, sizeof x);
    putchar('\n');

    return 0;
}

/* Dump the first n bytes to the address a */
void dumpHexa(void *a, int n) {
    int i;
    unsigned char *c = (unsigned char *)a;

    for (i = 0; i < n; i++)
        printf("%02x ", c[i]);
}

------------------------------------------------------------------

Synonym Pointer Types

Synonym pointer types simplify pointer definitions.

For example, let us define a synonym for a pointer to an int

 typedef int * Pint;

We can then define several pointer variables without having to include the * before each identifier

Pint px, py;

Note that this is more readable than the alternative primitive definition

int* px,* py;

------------------------------------------------------

IEEE 754
1,8,23 or 1,23,8 for double, long .
1.52,11 or 1,11,52 for long long.

Local Duration

A function parameter or a variable that is defined within a block has local extent unless otherwise specified. Its lifetime lasts from its definition until the closing brace of the block that contains that definition.

There are two distinct usages of local types:

normal
very frequent

For normal usage, we may add the keyword auto (for automatic) to the definition

 auto int local = 2;

Since this is the default for any function parameter or any variable defined within a block, we seldom see this keyword in practice.

For very frequent usage, we add the keyword register to the definition

 register int local = 2;

This keyword informs the compiler that the local variable should, if possible, remain in a CPU register as long as necessary. However, since the number of registers is extremely limited, the compiler might not implement such a request.

Internal Linkage

A variable of static duration with internal linkage is invisible outside its own module. To identify internal linkage, we add the keyword static to the definition

 static int local = 2;
/* Internal Linkage
* static.c
* May 12 2007
*/

#include 

void display() {
static int local = 0;

printf("local is %d\n", local++);
}

int main(void) {

display();
display();

return 0;
}

local is 0
local is 1

2010-06-06T16:17:00.002-04:00

Size of

The sizeof() operator evaluates to the size of a type in bytes. The sizeof operator (without the parentheses) evaluates to the size of a variable, object or expression in bytes. For example,

 /* Type Sizes
* sizeof.c
* May 14 2007
*/

#include 

int main(void) {
   double x;
   printf("On this machine, \n"
    "the size of an int is %d bytes,\n"
    "the size of x is %d bytes.\n",
    sizeof(int), sizeof x );
   return 0;
}









On this machine,
the size of an int is 4 bytes,
the size of x is 8 bytes.

Note that sizeof() takes a type, while sizeof takes a variable, object or expression. With some compilers, the two operators are interchangeable.

int type

An int type occupies one word of memory. One word is typically the size of a CPU register, making the int type the optimally efficient type. On 32-bit platforms, one word spans 4 bytes:

2010-06-02T23:16:00.010-04:00

A test is going to be taken tomorrow. Follow is my review

echo %errorlevel%

int d=foo();
return d;
------------------------------------------
int a[10] = {1,4,8,56,4,8,3,8,5,3};
int n = 0, i;
for(i=0;i<10;i++){ i="0;i<10;i++){">

int main(void){
int a = 5, b = 6;
if(b > 7 && (a = a + 1)){
printf("X\n");
}
printf("%d\n", a);/* 5 since b >7 is false */
getchar();
return 0;
}
--------------------------------------------
#include
int main(void){
int a[10]={1,4,9,0,4,6,3,2,5,3};
int i=0;
int j;
for(;i<10;){ i="0,j=" i="0,j=">
int main(void){
int a[5]={10,20,30,40,50};
int* p = &a[0]; //same as below */
printf("%d ", *a);
printf("%d ", *(p+0));
printf("%d ", *(a+1));
p++;
printf("%d ", *(p+2));
printf("%d ", (*p)++);
printf("%d ", *(p+2));
getchar();
return 0;
}

//answer 10 10 20 40 20 40
---------------------------------------------------------

#include
void foo(int** q){
(*q)++;
}
int main(void){
int a[5]={100,200,300,400,500};
int* p = a;
foo(&p);
printf("%d\n", *p);

return 0;
}

// comments **q =&p;
--------------------------------

#define PI 3.14159265 //It works In Borland C, don't work with VC and Lunix C
int main(void){
# ifdef sum
printf("PI is defined\n");
# elif PI == 3.14159265
printf("PI is not defined\n");
# endif
return 0;
}

//Conditional Compilation (#if, #ifdef, #ifndef, #else, #elif, #endif, and defined)

//(#ifdef #undef #endif)

Macro

2010-05-20T08:18:00.007-04:00

Cited from BTP300 Chris seneca cs Web

Continuation

A macro definition may extend over several lines. The backslash character - \ - immediately followed by the end-of-line character identifies a continuation onto the next line. For example,
#define PI 3.141\
592654
is the same as
#define PI 3.141592654

Efficiency and Flexibility
Function-like macros provide efficient and flexible solutions. They avoid the overhead of function calls and do not impose type constraints on the parameters in the macro definition.

#define SQUARE(x)  ((x) * (x)) /* NOTE THE PARENTHESES *// Fardad noted in class

Side-Effects

Macro definitions can also generate side effects. Because the pre-processor substitutes textual patterns rather than values, it can generate repeated evaluations of expressions that were intended to be a single evaluation. Such as area(r++).

 #define PI 3.14
#undef  PI
#define PI 3.14159    /* OK */
#define AREA(r) PI * r * r

Predeined macros

     printf("The name of the source file is %s\n", __FILE__);
printf("The date of its translation is %s\n", __DATE__);
printf("The time of its translation is %s\n", __TIME__);
if (__STDC__ != 0)
    printf("Compiled under Standard C\n");
else
    printf("Not compiled under Standard C\n");

reference macro

2010-05-20T08:00:00.000-04:00

Cited from course BTP300 , Chris, seneca cs web

C and C++ compilers process source code in three distinct stages: pre-processing, compilation proper and linking
mixed language program require linkage convention declarations to ensure that the function identifiers used in the definition and in the function call are identical

To resolve this incompatibility, we direct the C++ compiler to use the "C" linkage convention in calling hello() rather than the default C++ convention. We do so by wrapping the include directive in a linkage convention declaration:

 extern "C" {            /* identifies C linkage convention */
    #include "hello.h"
}

learning steps of SVN

2010-05-19T08:20:00.000-04:00

A repository location, however, is always a URL.
Schema Access Method
file:/// direct repository access (on local disk)
http:// access via WebDAV protocol to Subversionaware
Apache server
https:// same as http://, but with SSL encryption.
svn:// access via custom protocol to an svnserve
server
svn+ssh:// same as svn://, but through an SSH tunnel.

C:\> svn checkout file:///X:/path/to/repos
…
C:\> svn checkout "file:///X|/path/to/repos"

I create a personal Repository on my local disk. It seems pointless to create a personal Repos as long as only me use my pc at beginning, but I think it's still good idea to keep it in case i can trace my history codes even on offline status. It's kind of "Time Machine". I just wonder it is possible to sync one folder to 2 repositories?

OOP344

2010-05-17T19:15:00.000-04:00

Is Prof. Fardad's oop344 need use brain to get good mark?
The answer is "YES", I guess. I Didn't use my brain for long, it seems stuck right now, not sure how much lube I should fill in to run it smoothly, might it's mission impossible. Well, I will try my best. It's time to warm up.

mIRC

2010-05-13T21:24:00.000-04:00

WebBased IRC
http://webchat.freenode.net/

the mIRC client supports multi-threads. just right click the mIRC tray icon then click the channel name just above 'exit' it can switch back the channel I want. I cann't switch it back by press alt-tab keys.

register username

/msg nickserv register

To keep your email address private, rather than displaying it publicly, mark it as hidden:
/msg nickserv set hidemail on
It's useful, but not required, to have an alternate nick grouped to your account. For example, if your primary nick is foo:
/nick foo_
and then
/msg nickserv group
If you're running an older version of xchat and you've requested a cloak, you may need to follow these instructions so that your client will properly identify to Nickserv before joining any channels. Recent versions of xchat appear to handle things just fine.
Configure your client to identify itself to nickserv automatically whenever it connects to freenode so that it's less likely you'll connect to the network without being identified to nickserv. The easiest approach is to specify your nickserv password as a server password.

2010-05-12T22:58:00.000-04:00

May 12, 2010

My first blog, which will be dedicated to OOP344.

Fardad tries to let his students be familiar with lots of tools to apply in the open source environment. I like the point.

So far I have a personal wiki under the zenit site, a blog at myoop344blog.blogspot.com.

I installed svn client on my pc, and will install one on my mac.

also I have already added my personal information to student list, and my blog to planet CDOT feeder list

installed a mIRC client I can login yesterday but I cann't login today since I tried to register the nicename xlu44 on the freenode irc server.

I set my target on this course is A+.