От дума на дума

C++ classes rules

2011-08-11T16:38:00.002+03:00

#_______________________________________________________________________________

#

#   C++ notes during coding

#_______________________________________________________________________________

#



1. Basics

    

    * Do not write using declarations in header files.

    * Use delete for simple variables and delete[] for arrays.

    * Global variables are implicitly initialized to zero; the programmer must initialize all other variables.

      Compiler does not detect uninitialized local variables.



    * Use reference as auxiliary variables:

    for(int i = 0; i < SIZE; ++i) {

        int& p = a[i];            // very efficient when 'p' has to be referred many times 

        if(p == 0) {

           p = 1;

        }

    }


* function declaration = function signature
      function definition = function implementation

    * A function can return a reference type, and if it does, it can be called on either side of an assignment
      or in an I/O statement.

    * Enumerations do not have to be named if the name of the enumerator is sufficient

    * An array of objects requires a no-argument constructor because there is no way to specify the actual parameter of 
      constructor, which is called for all of the array elements when the array is created.

    * Static objects are destroyed (their destructors are executed) when the entire program terminates.

    * static keyword

Each name in a C++ source file, including functions and global variables, has a linkage that is either internal or external.
External linkage means that the name is available from other source files. Internal linkage (also called static linkage)
means that it is not. By default, functions and global variables have external linkage.

Initialization order of nonlocal variables in different source files is undefined.

    * namespaces

Think of scopes more like directories and "using" statements more like path variables - kind of like
"I won't remember the exact name of xxxxx.cpp but I will remember it's in my 'project_subdir' directory for example".
There's nothing wrong, per-se, with deeply nested namespaces in C++, except that they're not normally necessary as there's
no module system behind them, and the extra layers just add noise so avoid them.

Watch out for ADL(argument-dependent-lookup) when using namespaces!

The basic idea is what when the compiler finds a non-fully-qualified identifier it will try to match it
starting in the current namespace, and if not found it will try the enclosing namespace... all
the way to the root.

    * Anything which can appear on the left of = (that is, anything that can represent an address) is called an Lvalue.
      Anything which can appear on the right of = (that is, anything that can yield a value) is called an Rvalue.

    * What is a handle?

Sometimes libraries require client code to keep information returned from one interface in order to pass
it to another. This information is sometimes called a handle and is often used to keep track of specific
instances that require state to be remembered between calls. The term "handle" is sometimes used to describe
a pointer to a pointer to some memory(a pointer to some other C++ object). In some applications,handles are
used because they allow the underlying software to move memory around as necessary. Summarizing: accessing
something via a level of indirection. If the abstract model specifies that one object "contains" another,
your implementation does not have to make the contained object a data member of the containing object. Instead,
the containing object ca have a handle to the representation of the contained object. It is a good idea
to use smart pointers for all handles!

     * Libraries

  Static:
A static library contains object code that is linked with an end-user application and then becomes
part of that executable. A static library is sometimes called an archive because it is essentially just a package
of compiled object files. These libraries normally have a file extension of .a on UNIX and Mac OS X machines
or .lib on Windows, for example, libjpeg.a or jpeg.lib.
g++ -c file1.cpp

   g++ -c file2.cpp

   g++ -c file3.cpp

   ar -crs libmyapi.a file1.o file2.o file3.o

The -c option to g++ tells the compiler to produce a .o file from the input .cpp file. The options to
ar are -c creates an archive, -r inserts the supplied .o files into that archive, and -s creates an index
for the archive.

Your users can then link against your library using the -l option to ld or g++. This specifies the
name of the library to link against. The -L linker option can also be used to specify the directory
where your library can be found. For example,
g++ usercode.cpp -o userapp -L. -lmyapi

In this example, the end-user application userapp is created by compiling usercode.cpp and linking
against the libmyapi.a static library in the same directory.

The order of archives on this command line is significant. For each archive that the linker finds
on the command line, it looks to see if that archive defines any symbols that were referenced from
any object files specified earlier on the command line. If it does define any needed symbols, the
object files with those symbols are copied into the executable. It is therefore best practice to specify
libraries at the end of the command line.

While I am discussing the creation of static libraries, it is worth noting proper usage of
the -static compiler option. This flag is used for the creation of executables, not libraries. It is
therefore applicable to users of your API, but not to the building of your API itself. This flag
instructs the compiler to prefer linking the static versions of all dependent libraries into the executable
so that it depends on no dynamic libraries at run time.

  Dynamic:
Dynamic libraries are files linked against at compile time to resolve undefined references and then
distributed with the end-user application so that the application can load the library code at run time
This normally requires use of a dynamic linker on the end user’s machine to determine and load all dynamic
library dependencies at run time, perform the necessary symbol relocations, and then pass control to the application.
For example, the Linux dynamic linker is called ld.so and on the Mac it is called dyld.
Often, the dynamic linker supports a number of environment variables to modify or debug its behavior.
Dynamic libraries are sometimes called shared libraries because they can be shared by multiple programs.
On UNIX machines they can be called Dynamic Shared Objects, and on Windows they are referred to as Dynamic Link Libraries.
They have a .so file extension on UNIX platforms, .dll on Windows, and .dylib on Mac OS X,
for example, libjpeg.so or jpeg.dll.

Creating a dynamic library on Linux is a very similar process to creating a static library. Using the
GNU C++ compiler, you can simply use the -shared linker option to generate a .so file instead of
an executable.
On platforms where it is not the default behavior, you should also specify either the -fpic or the
-fPIC command line option to instruct the compiler to emit position-independent code (PIC). This is
needed because the code in a shared library may be loaded into a different memory location for different
executables. It’s therefore important to generate PIC code for shared libraries so that user code
does not depend on the absolute memory address of symbols. The following example illustrates how
to compile three source files into a dynamic library.
g++ -c -fPIC file1.c

   g++ -c -fPIC file2.c

   g++ -c -fPIC file3.c

   g++ -shared -o libmyapi.so -fPIC file1.o file2.o file3.o

Users can then link your dynamic library into their code using the same compile line shown earlier
for the static library case, that is,
g++ usercode.cpp -o userapp -L. -lmyapi

NOTE: If you have both a static library and a dynamic library with the same base name in the same directory,
that is, libmyapi.a and libmyapi.so, the compiler will use the dynamic library (unless you use
the -static library option to require only static libraries to be used). To favor use of a static library
over a dynamic library with the same base name, you could place the static library in a different
directory and ensure that this directory appears earlier in the library search path (using the -L linker
option).

Note also that in a dynamic library, all code is essentially flattened into a single object file. This is in
contrast to static libraries that are represented as a collection of object files that can be copied individually
into an executable as needed (i.e., object files in a static archive that are not needed are not
copied into the executable image). As a result, loading a dynamic library will involve loading all the
code defined in that .so file.

On Linux platforms, you can use the dlopen() function call to load a .so file into the current process.
Then you can use the dlsym() function to access symbols within that library. This lets you create
plugin interfaces, as described earlier. For example, consider the following very simple plugin
interface:
#ifndef PLUGIN_H

        #define PLUGIN_H

        #include <string>

            extern "C"

            void DoSomething(const std::string &name);

        #endif

You can build a dynamic library for this API, such as libplugin.so. Then the following code
demonstrates how to load this library and call the DoSomething() function within that .so file:
typedef void(*FuncPtrT)(const std::string &);

        const char *error;



        // open the dynamic library

        void *handle = dlopen("libplugin.so", RTLD_LOCAL | RTLD_LAZY);

        if (! handle) {

          std::cout << "Cannot load plugin!" << std::endl;

          exit(1);

        }



        dlerror();



        // get the DoSomething() function from the plugin

        FuncPtrT fptr = (FuncPtrT) dlsym(handle, "DoSomething");



        if ((error = dlerror())) {

           std::cout << "Cannot find function in plugin: " << error;

           std::cout << std::endl;

           

           dlclose(handle);

           exit(1);

        }

        

        // call the DoSomething() function

        (*fptr)("Hello There!");

        

        // close the shared library

        dlclose(handle);


* Assertions

The behavior of assert depends on the NDEBUG preprocessor symbol: if the symbol is not defined, the
assertion takes place, otherwise it is ignored. Compilers often define this symbol when compiling "debug"
builds. If you want to leave asserts in run time code, you must specify your compiler settings, or write
your own version of assert that isn't affected by the value of NDEBUG.

     * Use 0 for integers, 0.0 for reals, NULL for pointers, and '\0' for chars. 

     * Make crash course:
target : depends

           rule

  

        target  - the parameter given to make. I.e. what to build

        depends - file or other targets target depends on

        rule    - how to create target (note that rule is preceeded by a TAB char)



        $(VAR)  - environment variable or variable defined above

        $@      - current target

        $*      - current target without extension 

                  (the bit which matches the % wildcard in the rule definition)

        $<      - current dependency

        $^      - the names of all the dependencies space separated


* Doxygen crash course
- \file [<filename>]

       - \class <class name> [<header-file>] [<header-name>]

       - \brief <short summary>

       - \author <list of authors>

       - \date <date description>

       - \param <parameter name> <description>

       - \param[in] <input parameter name> <description>

       - \param[out] <output parameter name> <description>

       - \param[in,out] <input/output parameter name> <description>

       - \return <description of the return result>

       - \code <block of code> \endcode

       - \verbatim <verbatim text block> \endverbatim

       - \exception <exception-object> <description>

       - \deprecated <explanation and alternatives>

       - \attention <message that needs attention>

       - \warning <warning message>

       - \since <API version or date when the entity was added>

       - \version <version string>

       - \bug <description of bug>

       - \see <cross-references to other methods or classes>



       - \a <word>   Mark next word as a reference to a parameter.

       - \e <word>   Use italic font for the next word.

       - \b <word>   Use bold font for the next word.

       - \c <word>   Use typewriter font for the next word.

       - \sa <references>   Adds a section with cross references.

       - \bug <text>   Describe a known bug.

       - \todo <text>   Add a todo list.

       - \attention <text>   Add a section for something that needs attention.

       - \warning <text>   Add a section for a warning.

       - \anchor <refname>   Set an invisible anchor which can be used to create a link with \ref.

       - \ref <refname> [<text>]   Add a link to <refname>.

In addition to these commands, Doxygen supports various formatting

2. Object-oriented programming

    * Typical class structure:
// Foo.h

#ifndef _FOO_H_

#define _FOO_H_



// _____________________________________________________________________________

//                                                                     Includes



// Headers

#include "Bar.h"



// Forward declarations

class Joe;



// DO NOT USE: using namespace std;

/**

 * @ingroup 

 * @class Foo

 * @brief 

 *

 * @author

 * @version 1.0.0

 */

class Foo

{



// Public Types

public:

    typedef int FooValType;

    enum FooItemType  {

        FOO_ITEM_0,

        // ...

    };



// Private Members

private:

    FooValType _val;



// Public Methods

public:

    // Constructors

    Foo();

    virtual ~Foo();



    // Other methods

    void process(const Joe& aJoe);



    // getters/setters

    FooValType getVal() const;



    // toString

    friend std::ostream& operator<<(std::ostream& ostr, const Foo& inFoo);



// Private Methods

private:

    DISALLOW_COPY_AND_ASSIGN(Foo);

    void _process() const;

};



// _____________________________________________________________________________

//                                                               Inline methods



// Small and fast methods that change the object state



// _____________________________________________________________________________

//                                                               Static methods



// Static method from class interface



#endif /* _FOO_H_ */


* The relative order of initialization of non-local static objects in different translation units is
      undefined
    * In the C++ object model, protection is applied at the class level and
      not at the object level. An object "beta" of class X can access everything inside another 
      object - "alpha", of class X without any restrictions. For example in copy constructors
      you can use private data of source object.
    * Every class presents two interfaces: one to the users, another to the derived classes
    * Implicitly declared constructors are publicinlinemembers of their class
    * Initialization order is declared in the class itself, not in the constructor!    
    * Don’t attempt to call one constructor of a class from another.
    * The assignment operator should check for self-assignment and return a reference to "this".
    * When creating an object on the stack, omit parenthesis for the default constructor.
    * Pass objects by const reference instead of by value.
    * Returning a reference to a data member is risky because the reference is valid only as long as the object is "alive"
    * = does not always mean assignment! It can also be shorthand for copy construction
      when used on the same line as the variable declaration:
SpreadsheetCell aThirdCell = myCell;   // aThirdCell is constructed with the copy constructor

      anotherCell = myCell;                  // Calls operator= for anotherCell.

* Don't use "extern" declarations
    * The virtual keyword has a few subtleties and is often cited as a poorly designed part of the language.
      There is a lot of problems associated with omission of the virtual keyword. So to avoid problems:

As a rule of thumb, make all your methods virtual (including the destructor, but not
constructors) to avoid problems associated with omission of the virtual keyword.

Attempting to override a non-virtual method will "hide" the superclass definition
and will only be used in the context of the subclass.

Constructors cannot and need not be virtual because you always specify the exact class 
being constructed when creating an object.

    * When upcasting, use a pointer or reference to the superclass to avoid slicing.
    * Use downcasting only when necessary and be sure to use a dynamic cast.
    * Uses multiple inheritance only for the implementation of mix-in classes

A mix-in class adds new capabilities to other classes. They represent static relationship and usually they
are pure virtual classes so no one creates an instance of a mix-in class. It does not make any sense
to create an instance of mix-in class because the mix-in class adds flavor to some other class - it is to be
mixed in with another class. A mix-in class answers the question "What else is this class able to do?" and the
answer often ends with "-able." Naming convention is mix-in class to end with "-able" e.g. Callable.

    * When you override a method, you are implicitly hiding any other versions of the method!
      It makes sense if you think about it — why would you want to change some versions of a method and not others?

To avoid obscure bugs, you should override all versions of an overloaded method,
either explicitly or with the "using" keyword.
class Foo {

        public:

          virtual void overload() { cout << "Foo's overload()" << endl; }

          virtual void overload(int i) { cout << "Foo's overload(int i)" << endl; }

      };

      class Bar : public Foo {

        public:

          using Foo::overload;

          virtual void overload() { cout << "Bar’s overload()" << endl; }

      }


If your API does not call a particular method internally, then that method probably should not be virtual.
You should also only allow subclassing in situations where it makes sense: where the potential subclasses form an "is-a"
relationship with the base class.

   * Overloading works only within the scope of a single class!

   * Don't change the default parameters of the inherited functions you override.
     When overriding a method that has a default argument, you should provide a default argument as well,
     and it should probably be the same value.
   
   * The only truly useful way to change a method’s access level is by providing a less
     restrictive accessor to a protected method.

   * If your subclass does not specify its own copy constructor or operator=, the parent
     functionality continues to work. If the subclass does provide its own copy constructor
     or operator=, it needs to explicitly reference the parent versions.

   * Note that the runtime-type information is stored in the vtable of the object. Therefore, in order to use
     dynamic_cast, your classes must have at least one virtual function. Use dynamic_cast<> to restore
     lost type information

   * Do not mix and match malloc() and free() with new and delete. Use only new and delete.
     As a rule of thumb, every line of code that allocates memory with new should correspond
     to another line of code that releases the same memory with delete.

   * Calling "delete" twice is incorrect and leads to undefined behavior
   * Do not throw exceptions from destructor

   * Member initialization list: variables of primitive data types are initialized through assignments,
     while variables of class types are initialized by calling copy constructor.

   * Always List any Superclass Constructors in the Initializer List of a Subclass Constructor

   * When object that contains nested classes goes out of scope, the destructors for nested objects are called
     (in revert order of construction)

   * The definitions of static members occur outside the class in the implementation file

   * Constant static attributes can be initialized within the class definition if they are of an integral type, and
     the initialization expression must be constant.

   * An operation in a class "C" that returns a new object should have a return type "C" and should allocate this
     object on the stack
Integer Integer::clone() const {

       Interger res(_value);

       return res;

     }

* Use "new" when you don't know exact type until runtime. In other words when you expect to use polymorphism (late binding)
     Operations with a late binding mus be invoked through a pointer or a reference.

   * Covariant return types! If a virtual operation in the base class returns a class type, a reference to a class type,
     or a pointer to class type, the same virtual operation in a derived class can return a class(or a reference or a pointer) 
     that is publicly derived from the base class. That is, the return types in the base class and in the derived class do not
     have to be strictly identical.

   * To provide a default implementation that must be redefined in a derived class, use pure virtual operations and provide
     there implementation

   * Avoid calling virtual functions in constructors and destructors

   * When we have a pure virtual function in any class then it prevent us to create any instance of that class.
     That is we cannot make the object of that class. Now if you want to prevent a class from being instantiated
     but at the same time you don't want to declare any pure virtual method inside it, then there is no way except that
     you make your destructor as pure virtual. You cannot make your constructor as pure virtual and you don't have any other
     method to make pure virtual then in that case you are left with only one alternative of making your innocent destructor
     as pure virtual to avoid your class to be instantiated.

   * A fiend function is not implemented inside the class granting friendship (unless it is an inline declaration and 
     definition for the friend function which is rare). A friend function lives in another class or it could be a
     free function not attached to any class. A function(or class) can not proclaim itself to be a friend of another class.
   
   * Friend mechanism is can not be transitive - friend of a friend is NOT friend
   
   * Friendship is not inherited


3. References

You can think of references as just another name for the original variable!
Taking the address of a reference gives the same result as taking the address of the variable to
which the reference refers. References are const by default, in that you can’t change to what they refer.

So, C++ does not allow you to mark a reference variable explicitly const!
int x = 3;

      int& xRef = x;

      int* xPtr = &xRef; // Address of a reference is pointer to value

      *xPtr = 100;       // x will be changed

You must always initialize a reference when it is allocated. Usually, references are
allocated when they are declared, but reference data members can be initialized in
the initializer list for the containing class.

You cannot change the variable to which a reference refers after it is initialized; you
can only change the value of that variable.

You cannot declare a reference to a reference or a pointer to a reference. 
You must initialize reference data members in the constructor initialization
list, not in the body of the constructor

A common quandary arises when you have a pointer to something that you need to pass to a function or
method that takes a reference. You can "convert" a pointer to a reference in this case simply by
dereferencing the pointer.
void swap(int& first, int& second);

      ........

      int x = 5, y = 6;

      int *xp = &x, *yp = &y;

      swap(*xp, *yp);

You can't pass constants as arguments to functions that employ pass-by-reference:
swap(3, 4); // DOES NOT COMPILE

You can also return a reference from a function or method. The main reason to do so is efficiency.
But be careful - never return a reference to a variable, such as an automatically allocated variable on
the stack, that will be destroyed when the function ends. A second reason to return a reference is if you
want to be able to assign to the return value directly as an lvalue. For example, several overloaded operators
commonly return references.

Almost everything you can do with references, you can accomplish with pointers.
If the code receiving the variable is responsible for releasing the memory associated with an object,
it must receive a pointer to the object. If the code receiving the variable should not free the memory,
it should receive a reference! The only case in which you need to use a pointer instead of reference
is when you need to change the location to which it points.

Because return references do not invoke copy constructors, they may be more efficient than functions
that return objects.

When you have class methods that change object state (e.g set/add) it is good practice to return 
reference type not void and terminate with a statement of the form:
.........

      return &this;

In this way you can chain e.g. if we have "add" method then
i.add(5).add(7);

But do not return a reference to attributes of a class(common error).
     
    * A function should not return a reference to a heap-based object that was allocated in the function.

Reference and pointer attributes have the values referenced by them changed instead of their own values,
and so the do not have to be specified as mutable.
     
4. Be const correct

General rule for const pointers: const applies to the level of indirection directly to its left!
There is alternative syntax but I use this one.
const int my_constant = 10

    An int which can't change value. Similar to #define in C but better.



int const* my_constant

    Variable pointer to a constant integer.

const int* my_constant

    Alternative syntax, the same as above.



int* const my_constant

    Constant pointer to a variable integer.



int const* const my_constant

    Constant pointer to a constant integer.

const int* const my_constant

    Alternative syntax, the same as above.



void my_method(QString const& my_paramater)

    my_paramater will not be altered by the method.

    '&' means it can be altered but here we just want it to be used because it saves taking a copy.

class MyClass {

      void my_method() const;

      int my_variable;

 }

my_method() will not alter any member variable (my_variable), this means you can call the method from a const variable.
int const* const my_method(const int* const&) const

It will return a pointer which is constant and points to a constant integer,
    the method doesn't alter either the variable pointed to by the parameter
    or the pointer itself and it doesn't alter any of the member variables of the object the method is it. 

The const-ness of parameter can be used to define an overloaded function but only if this parameter is passed
by reference.

How to read const?

Rule a: If a const and/or volatile is next to a type specifier (int, long, etc.) it applies to that specifier.
Rule b: if a const and/or volatile is not next to a type then it applies to the pointer asterisk on its immediate left.
    
5. Arrays

    * The advantage of putting an array on the heap is that you can use dynamic memory to define its size at run time.
int numDocs = askUserForNumberOfDocuments();

       Document* docArray = new Document[numDocs];    // dynamic size

* If you have an array of pointers, you will still need to delete each element individually just as you
      allocated each element individually and after that to delete array itself.

    * If you need to determine the dimensions of a multidimensional array at run time, you can use a heapbased array but:
char** board = new char[i][j]; // DOES NOT COMPILE!

You can allocate the first dimension array just like a single-dimensional heap-based array, but the individual subarrays
 must be explicitly allocated.

6. Pointers

 Pointers are something like that: A pointer is simply a level of indirection that says to the program "Hey! Look
 over there.". When you take the address of a variable, using the & operator, you are adding a level of indirection in
 memory. In the address-based view, the program is simply noting the numerical address of the variable,
 which can be stored in a pointer variable. In the graphical view, the & operator creates a new arrow whose point ends
 at the variable.

    * You can assign a string to a char* without const, and the program will work fine unless you attempt to change the string.
      A much safer way to code is to use a pointer to const characters when referring to string literals.
const char* ptr = "hello"; // Assign the string literal to a variable.

       ptr[1] = 'a';              // BUG! Compiler will catch it.

* For compatibility, you can convert a C++ string into a C-style string by using the
      c_str() method. You should call the method just before using the result so that it
      accurately reflects the current contents of the string.

    * Each function actually lives at a particular address. In C++, you can use functions as data.
Function pointers are typed according to the parameter types and return type of compatible functions!
The easiest way to work with function pointers is to use the typedef mechanism to assign a type name
to the family of functions that have the given characteristics.
// type called YesNoFunc that pointer to any function that has two int parameters and returns a bool.

        typedef bool(*YesNoFunc)(int, int); 

Any function that return bool and accepts parameters two integer could be represented by this type.

    * Nested objects and shared pointers
class Example {

        public: 

        // ...

        private:

          boost::scoped_ptr<Owned> data;

       };

scoped_ptr is very good for this purpose. But one has to understand its semantics. You can group smart pointers using two major properties:
     - Copyable: A smart pointer can be copied: The copy and the original share ownership.
     - Movable: A smart pointer can be moved: The move-result will have ownership, the original won't own anymore.

That's rather common terminology. For smart pointers, there is a specific terminology which better marks those properties:
     - Transfer of Ownership: A smart pointer is Movable
     - Share of Ownership: A smart pointer is copyable. If a smart pointer is already copyable, it's easy to support
       transfer-of-ownership semantic. That then is just an atomic copy & reset-of-original operation, restricting that to smart
       pointers of certain kinds(e.g only temporary smart pointers).

Let's group the available smart pointers, using (C)opyable, and (M)ovable, (N)either:
     1. boost::scoped_ptr: N
     2. std::auto_ptr: M
     3. boost::shared_ptr: C

auto_ptr has one big problem, in that it realizes the Movable concept using a copy constructor.
auto_ptr<int> a(new int), b;

       // oops, after this, a is reset. But a copy was desired!

       // it does the copy&reset-of-original, but it's not restricted to only temporary

       // auto_ptrs (so, not to ones that are returned from functions, for example).

       b = a;

NOTE: See also boost::weak_ptr

TIP: Always prefer passing a non-mutable object as a const reference rather than passing it by value. This will avoid
     the memory and performance costs to create and destroy a temporary copy of the object and all of its member and
     inherited objects.

    * Ownership

Be careful with code like this
void doSomething(Simple*& outSimplePtr) {

      outSimplePtr = new Simple(); // BUG! Doesn't delete the original.

    }

Valgrind catch the problem. Learn how to read Valgrind messages!

7. I/O
   
    goodbit   The stream is in a "good" state — nothing’s wrong
    eofbit    The stream is positioned at end-of-file — no more data can be read
    failbit   An operation failed but recovery is possible
    badbit    The stream has “lost integrity” and cannot be used any more

    * Every input stream has an associated source. Every output stream has an associated
      destination.
    * Not all output streams are buffered. The cerr stream, for example, does not buffer
      its output.
    * By default, the input stream will tokenize values according to white space.
    * The methods that read in data from a stream(take iostream as a parameter) will change the actual
      stream (most notably, its position), so they are not const methods. Thus, you can’t call them  on a const reference.
    * String streams provide a way to use stream semantics with strings. In this way, you can have an inmemory
      stream that represents textual data. There are useful for parsing text, because streams have built-in
      tokenizing functionality. The main advantage of a string stream over a standard C++ string is that, in addition to data,
      the object knows about its current position.
    * Stream linking is accomplished with the tie() method. To tie an output stream to an input stream, call
      tie() on the input stream, and pass the address of the output stream. To break the link, pass NULL.
    * The fstream class provides a bidirectional file stream. fstream is ideal for applications that need to
      replace data within a file because you can read until you find the correct position, then immediately
      switch to writing. But be careful:
   
Bidirectional streams have separate pointers for the read position and the write position.
When switching between reading and writing, you will need to seek to the
appropriate position.

    * A locale is a collection of settings about a particular location. An individual
      setting is called a facet (e.g format used to display a date). Most operating systems have a mechanism to determine
      the locale as defined by the user.
      In C++, you can pass an empty string to the locale object constructor to create a locale from the user’s environment.
    
8. Exceptions

    * The dark side of C++ exceptions:
void g() {

        throw std::exception();

      }

      void f() {

        int *i = new int(2);

        *i = 3;

        g();

        // Oops, if an exception is thrown, i is never deleted

        // and we have a memory leak

        delete i;

      }

      int main() {

        try {

          f();

        }

        catch(...) { }

        return (0);

      }    

* In C++ a function that does not specify a list of exceptions can throw any exception it wants! A function without
      a throw list can throw exceptions of any type. A function with an empty throw list shouldn’t throw any exception.
      Unfortunately, the throw list is not enforced at compile time in C++.

    * Your programs can catch exceptions by value, reference, const reference, or pointer.
} catch (const char* e) {       // when you throw error message  

          } catch (const exception& e) {

But generally catch exceptions with const to document that you are not modifying them.

    * The keyword throw by itself simply rethrows whatever exception was caught most recently.
} catch (...) {

            delete str;

            throw;         // Rethrow the exception.

          }

* Use auto_ptr to write exception save code:
void myFunction() {

	auto_ptr ptr( new T ); 

	/*... code that throws exception...*/ 



	// ptr’s destructor gets called as the function’s stack unwinds here & the object 

	// gets deleted automatically

    }

* It’s important to know about set_terminate(), it’s not a very effective exception-handling
      approach. We recommend trying to catch and handle each exception individually in order to provide
      more precise error handling.
    * Unlike const, the exception specification is not part of the function or method signature. You cannot
      overload a function based solely on different exceptions in the throw list.
    * Throw lists don’t prevent functions from throwing unlisted exception types, but
      they prevent the exception from leaving the function.    
    * The unexpected() function applies program-wide, not just to this function, so you should reset the handler 
      when you are done with the code that needed your special handler.
    * If you change throw lists when you override methods, remember that any code that
      called the superclass version of the method must be able to call the subclass version.
      Thus, you can’t add exceptions.
    * When you catch exceptions polymorphically, make sure to catch them by reference.
      If you catch exceptions by value, you can encounter slicing, in which case you lose
      information from the object.
    * Objects thrown as exceptions are always copied by value at least once. Thus,
      if you write a class whose objects will be thrown as exceptions, you must make those objects copyable.
      This means that if you have dynamically allocated memory, you must write a destructor, copy constructor,
      and assignment operator. Catch exception objects by reference to avoid unnecessary copying.

When a piece of code throws an exception, control jumps immediately to the exception handler that
catches the exception. This exception handler could lie one or more function calls up the stack of execution.
As the control jumps up in the stack in a process called stack unwinding, all code remaining in each
function past the current point of execution is skipped. However, local objects and variables in each
function that is unwound are destroyed as if the code finished the function normally. However, in stack unwinding,
pointer variables are not freed, and other cleanup is not performed.

    * Smart pointers allow you to write code that automatically prevents memory leaks with exception handling
    * C++ guarantees that it will run the destructor for any fully constructed "subobjects"
    * RAII programming idiom

The idea is to wrap the resource release operation in a destructor of an object in the scope. Language guarantees
that the destructor will always be invoked (of a successfully constructed object) when control flow leaves the scope
because of a return statement or an exception.

NOTE: Prefer to think of it as Stack-Based Resource Management because it tells a little more about what is going
on and what the goal is.

The thing that gives destructors more expressiveness for dealing with cleanup is that they only execute
for the objects that have been initialized. This means that if control exits a block after only half of the stack-local
objects have been constructed, only those half of the objects have their destructors invoked.
With finally, all that bookkeeping is the responsibility of the programmer.

9. Overloading C++ Operators

The general guiding principle is to make your classes behave like built-in types. The second reason to overload operators
is to gain greater control over behavior in your program. It’s important to emphasize that operator overloading doesn't
necessarily make things easier for you as the class developer; its main purpose is to make things easier for clients of the class.
When the operator is a method of a class, the left-hand-side of the operator expression must
always be an object of that class. If you write a global function, the left-hand-side can be an object of a different
type.

    * Operators that must be methods: When the operator is a method of a class, the left-hand-side of the operator expression must
      always be an object of that class.
    * Operators that must be global functions: Whenever you need to allow the left-hand side of the
      operator to be a variable of a different type from your class, you must make the operator a global
      function.
    * Operators that can be either methods or global functions: Make every operator a method unless you
      must make it a global function as described previously. One major advantage to this rule is that
      methods can be virtual, but friend functions cannot. Therefore, when you plan to write overloaded
      operators in an inheritance tree, you should make them methods if possible.
    * Choosing Argument Types: The choice of value vs. reference is easy: you should take every parameter by reference.
    * The const decision is also trivial: Mark every parameter const unless you actually modify it.
      A return value that can be modified as an lvalue (the left-hand-side of an assignment expression) must be
      non-const. Otherwise, it should be const.
    * C++ doesn’t determine overload resolution based on return type. Thus, you can specify any return type you want
      when you write overloaded operators. However, you should write your overloaded operators such that they return
      the same types as the operators do for the built-in types. The general rule for value or reference is to return
      a reference if you can; otherwise, return a value.

An l-value operator(operators that are invoked on existing objects) can return a reference to the object on the LHS,
the target of the operator call. This is safe, efficient and the correct way to implement an l-value operator.

Commutative operators (+, -, etc.) that compute the result from their operands, cannot return a reference or a
pointer. Naturally such operators return the result by value.

    * Operators You Shouldn’t Overload: operator&& operator|| operator, and operator&
    * (C++ hack)The prefix versions of operator++ and operator-- take no arguments,
      while the postfix versions take one unused argument of type int
    * postfix operation e.g. operation++(int) returns old value for the use in the rest of expression
      prefix operation e.g. operation++ returns new value
    * The C++ standard specifies that the prefix versions of increment and decrement return an lvalue, so
      they can’t return a const value.
    * The operator[] can replace both setElementAt() and getElementAt() because it returns a reference to the element at location x.
    * You cannot overload the subscripting operator(operator[]) to take more than one parameter. If
      you want to provide subscripting on more than one index, you can use the function
      call operator.
    * C++ allows you to overload the function call operator, written as operator(). If you write an operator()
      for your class, you can use objects of that class as if they were function pointers. You can only overload this
      operator as a non-static method in a class.
    * An object of a class with a function call operator (operator()) is called a function object, or functor for short.
      The advantage of function objects over standard methods of objects is simple: these objects can sometimes
      masquerade as function pointers. You can pass function objects as callback functions to routines that expect function pointers,
      as long as the function pointer types are templatized. This is a function with state - closure.
    * You can overload the dereferencing operators for your classes in order to make objects of the classes
      behave like pointers. In this way you can implement smart pointers.

    * There are two differences between the prefix and postfix increments: their return type and their arguments.
      The prefix version returns the modified object. It may seem odd that the postfix version of ++ returns a new object,
      rather than a modified object.

    * It is quite common to implement operator== as a virtual member function. However, it's counterpart, operator!= need
      not to be a virtual function because it is implemented in terms of operator==
class X {

  public:

    virtual bool operator==(const X& rhs) const { /* code is here */}

    bool operator!=(const X& rhs) const { return !(*this == rhs); }

} 

* Any operation that does NOT REQUIRE an l-value and is commutative is better implemented as a non-member function(+, - etc.).
      This allows the compiler to applay a conversion in case of argument mismatch for the first argument.

    * Any operation that REQUIRE an l-value is better implemented as a member function. This clearly shows that it can be invoked
      on existing, modifiable objects.

Implementing operator-> is tricky!

The result of applying the arrow operator should be a member or method of an object.
However, in order to implement it like that, you would have to be able to implement the equivalent of operator* 
followed by operator.. C++ doesn’t allow you to overload operator. for good reason: it’s impossible to write a 
single prototype that allows you to capture any possible member or method selection. Similarly, you couldn't write
an operator-> with such semantics. Therefore, C++ treats operator-> as a special case.

Consider this line:
smartCell->set(5);

C++ translates the preceding to:
(smartCell.operator->())->set(5);

As you can see, C++ applies another operator-> to whatever you return from your overloaded operator->

Conversions for Boolean Expressions

It is handy to use pointers in conditional statements like this:
if (classPtr != NULL) {

           // Perform some dereferencing action.

        }

To do that you have to overload operator void*() (see type conversion operator T())

    * You can predefine only operator<, then
 

      x > y can be expressed as y < x

      x >= y can be expressed as !(x < y)

      x <= y can be expressed as !(y < x) 


10. Tests
  1. What are the things that this piece of code was written to do?

     2. What are the typical ways each method would be called?

     3. What preconditions of the methods could be violated by the caller?

     4. How could each method be misused?

     5. What kinds of data are you expecting as input?

     6. What kinds of data are you not expecting as input?

     7. What are the edge cases or exceptional conditions?

  Once you have generated ideas for some of the tests you would like to use, consider how you might
organize them into categories and the breakdown of tests will fall into place.

     1. Basic tests
     2. Error tests
     3. Internationalization tests
     4. Bad input tests
     5. Complicated tests

Important: Decide on the correct output for your test before you ever run the test.

Write the Tests Guideline:
1. Make sure that you’re only testing one thing in each test. That way, if a test fails, it will point to

        a specific piece of functionality.

     2. Be specific inside the test. Did the test fail because an exception was thrown or because the

        wrong value was returned?

     3. Use logging extensively inside of test code. If the test fails some day, you will have some insight

        into what happened.

     4. Avoid tests that depend on earlier tests or are otherwise interrelated. Tests should be as atomic

        and isolated as possible.

     5. If the test requires the use of other subsystems, consider writing stub versions of those subsystems

        that simulate the modules’ behavior so that changes in loosely related code don’t cause the

        test to fail.

     6. Ask your code reviewers to look at your unit tests as well. When you do a code review, tell the

        other engineer where you think additional tests could be added.

NOTE: A fixture is simply a logical group of tests

An integration test covers areas where components meet. Unlike a unit test, which generally acts on the
level of a single class, an integration test usually involves two or more classes. Integration tests excel at
testing interactions between two components, often written by two different programmers. In fact, the
process of writing an integration test often reveals important incongruities in designs.

System tests operate at an even higher level than integration tests. These tests examine the program as a
whole. System tests often make use of a virtual user that simulates a human being working with the program.
Of course, the virtual user must be programmed with a script of actions to perform. Other system
tests rely on scripts or a fixed set of inputs and expected outputs.

Regression testing is more of a testing concept than a specific type of test. The idea is that once a feature
works, developers tend to put it aside and assume that it will continue to work. Unfortunately, new features
and other code changes often conspire to break previously working functionality. Regression tests
are often put in place as a sanity check for features that are, more or less, complete and working. If the
regression test is well written, it will cease to pass when a change is introduced that breaks the feature.

  What to Test?
- Condition testing. When writing unit tests, you should use your knowledge of the code under
test to exercise all combinations of any if/else, for, while, and switch expressions within the
unit.

- Equivalence classes. An equivalence class is a set of test inputs that all have the same expected
behavior. The technique of equivalence class partitioning therefore attempts to find test inputs
that exercise difference classes of behavior.

- Boundary conditions. Most errors occur around the boundary of expected values. How many
times have you inadvertently written code with an "off-by-one" error?

- Parameter testing. A test for a given API call should vary all parameters to the function to verify
the full range of functionality.

- Return value assertion. This form of testing ensures that a function returns correct results for
different combinations of its input parameters.

- Operation order. Varying the sequence of operations to perform the same test (where this is possible)
can help uncover any order of execution assumptions and non-orthogonal behavior.

- Negative testing. This testing technique constructs or forces error conditions to see how the code
reacts to unexpected situations.

- Buffer overruns. A buffer overrun, or overflow, is when memory is written past the end of an
allocated buffer.

- Memory ownership. Memory errors are a common cause of crashes in C++ programs. Any API
calls that return dynamically allocated memory should document whether the API owns the memory
or if the client is responsible for freeing it. These specifications should be tested to ensure that
they are correct. For example, if the client is responsible for freeing the memory, a test could
request the dynamic object twice and assert that the two pointers are different. A further test
could free the memory and then rerequest the object from the API multiple times to ensure that
no memory corruption or crashes occur.

- NULL input. Another common source of crashes in C++ is passing a NULL pointer to a function
that then immediately attempts to dereference the pointer without checking for NULL. You
should therefore test all functions that accept a pointer parameter to ensure that they behave
gracefully when passed a NULL pointer.

#_______________________________________________________________________________
#                                                            Articles and links

http://www.gotw.ca/gotw/index.htm

http://strlen.com/rants/javaclassesincpp.html     

http://make.paulandlesley.org/autodep.html

http://www.newty.de/fpt/

http://www.mactech.com/articles/mactech/Vol.16/16.07/UsingFlexandBison/

http://gnuu.org/2009/09/18/writing-your-own-toy-compiler/

#_______________________________________________________________________________
#                                                                         Books

C/C++ listmania:
   http://www.amazon.com/Destination-C-C/lm/1RXP5YEYOG4HX/ref=cm_lm_byauthor_title_full

It is not a book but it is very useful resource:
   http://www.parashift.com/c++-faq-lite/

SQL crash course

2011-04-18T13:41:00.002+03:00



1 Database
~~~~~~~~~~~~~~~~~~~~~~~

Before you start to create database you're going to need to have better idea of
  what kinds of data you're going to want to store and some ways to categorizing it.

  Database is a container that holds tables and other SQL structures related to
  those tables. Tables are connected in some way.

2  Tables
~~~~~~~~~~~~~~~~~~~~~~~
What is a table anyway?

A column is a piece of data stored by your table. A row is a single set of columns that describe attributes of single thing.
Columns and rows together make up a table.
 
  You can identify categories for the type of data you're collecting. Your categories then become your
  columns. Type could be person, employer etc. Type is your row.

  You need a database for your tables:
CREATE DATABASE zlatozar_test;
You have to tell RDBMS which database you are going to use:USE zlatozar_test;
And remember SQL is case insensitive!  Capitalization and underscores help you to program in SQL.CREATE TABLE doughnut_list
  (
  doughnut_name VARCHAR(10),
  doughnut_type VARCHAR(6)
  );
Choosing the best matching data type for each column in your table will reduce the size and make  operations on your data faster. You can't recreate an existing table or  database. Here is some basic rules:  1. Break you data up in categories before you create your table. Pay special     attention to the type of data for each column.  2. TIMESTAMP is usually used to capture the current time. DATETIME is best used     to store a future event.  3. Check your work with:DESC doughnut_list;
How to delete a table?DROP TABLE doughnut_list;
DROP TABLE deletes your table and any data in it. Now it is possible to recreate table and put new  categories.  How to insert in a table?INSERT INTO your_table (col_name1, col_name2, ....)
  VALUES ('val1', 'val2', ....);
Values has to be in the same order as the column names. Any value that goes into a VARCHAR, CHAR, DATE,  or BLOB column has single quotes around it. DEC and INT don't use quotes.  You can insert few columns and leave some out.  NULL will be inserted for missing. NULL is not zero, it is "nothing" - undefined value.  A column with a NULL value IS NULL, but does not EQUAL NULL!  A good practice is to avoid it, but how?  Check what is inserted:SELECT * FROM doughnut_list;
- You can control NULL!CREATE TABLE doughnut_list
  (
      doughnut_name VARCHAR(10) NOT NULL,
      doughnut_type VARCHAR(6) NOT NULL
  );
- You can add defaults.CREATE TABLE doughnut_list
  (
      doughnut_name VARCHAR(10) NOT NULL,
      doughnut_type VARCHAR(6) NOT NULL,
      doughnut_cost DEC(3, 2) NOT NULL DEFAULT 1.00
  );
Using DEFAULT value fills the empty columns with a specified value.3 SELECT statement ~~~~~~~~~~~~~~~~~~~~~~~3.1 WHERE ==========   We use WHERE clause that five the RDBMS something specific to search for. SELECT well return the rows that match the condition.   The VARCHAR, CHAR, BLOB, DATE and TIME data types needs single quotes.   DEC and INT, no not.   RDBMS will ignore the quotes and treat your DEC and INT values as numbers,   even though the quotes indicate they are text values!   When inserting quotes have to be escaped with *\* or double *'*.   You can specify which columns wish to see. Use '*' to see all.   Use AND, OR for better WHERE condition. We can have more than one AND, OR.  =  equal  <> not equal  <  less than  >  greater than  <= and =>   Exception is NULL!SELECT drink_name FROM drink_info WHERE calories IS NULL;
3.2 LIKE =========   %  stand-in for any number of unknown character.   LIKE '%CA', any end with CA   _  stand-in for only one unknown character.   3.3 Selecting ranges =====================   1st  .... WHERE calories > 30 AND calories < 50;   2nd  ... WHERE calories BETWEEN 30 AND 50; (including 30 and 50);3.4 IN =======  ... rating IN ('innovative', 'fabulous');3.5 NOT ========   NOT lets you negate your results and get the opposite values.4 DELETE and UPDATE ~~~~~~~~~~~~~~~~~~~~~~~~  You can't relay on the rows in the table being in chronological order.  You can't use DELETE to delete the value from a single column or tableful of column.  You can delete every row from the table with:DELETE FROM your_table;
Be careful with DELETE, use SELECT first to be sure you will delete the right data.  You can use UPDATE tho update a single row or multiple rows, depending on the WHERE clause.  Update can replace DELETE/INSERT combination.  UPDATE statements can be used on multiple records in your table. Use them with basic math operations to manipulate your numeric values.5 Importance to be Normal~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  The simpler query the better!  How you're going to use your data will affect how you set up your table.  Relational database means how the columns relate to each other to describe the thing.  The challenge is to describe the thing using column in a way that makes getting the information out of it easy.  Here is a simple plan:  1. Pick your thing, the one thing you want your table to describe.     (What's the main thing you want your table to be about?)    2. Make a list of the information you need to know about your one thing when you're     know about your one thing when you're using the table.     (How will you use this table?)    3. Using the list, break down the information about your thing into pieces you can use     for organizing your table.     (How can you most easily query this table?)Atomic data: Data is atomic if it's been broken down into smallest piece of data thatcan't or shouldn't be divided.Simple rules to have atomic data:1. What is the ONE THING your table describes?2. How will you use the table to get at the ONE THING?   (Design your table to be easy to query)3. Do your columns contain atomic data to make your queries short and to the point?TIP: Making your data atomic means breaking it down into the smallest pieces that you needto create an efficient table, not just the smallest possible pieces you can.Here is the official rules for atomic data:  Rule 1: A column with atomic data can't have several values of the same type of data in a column.  (You don't have to look for cell information using LAKE)  Rule 2: A table with atomic data can't have multiple columns with the same  type of data.          teacher    student_1   student_2   student_3           ----------+------------+------------+------------          Zlatozar   Eli          Rosi         Monika      Too many student columns!Making your table NORMAL, means they follow some standard rules, so making your data atomicis the first step in creating a NORMAL table!Benefits of NORMAL tables- Normal tables won't have duplicate data, which will reduce the size of your database.- Faster queries.5.1 1NF ========   Each row of data must contain atomic values.   Each row of data must have a unique identifier, known as Primary Key (no repeating groups of data)   Hm, and what is Primary Key?   A primary key is a column in you table that makes each record unique.   Primary Key rules:   - A primary key can't be NULL.   - The primary key must be given a value when the record is inserted.   - The primary key must be compact   - The primary key values can't be changed   TIP: The best primary key may be a new primary key.   A key made of two or more columns is known as a COMPOSITE KEY.   COMPOSITE KEY is a primary key composed of multiple columns, creating a unique key.   TIP:   SHOW CREATE TABLE my_table_name;   gives you the SQL for table creation and you can use copy paste.   Try also:SHOW COLUMNS FROM table_name;
  SHOW CREATE DATABASE databse_name;
  SHOW INDEX FROM table_name;
Example for table creation that has primary key:CREATE TABLE my_contacts
  (
      contact_id INT NOT NULL AUTO_INCREMENT,
      ............
      PRIMARY KEY (contact_id)
  )
You can add primary key with ALTER. It will add keys to all rows.   6 ALTER ~~~~~~~~~~~~  The ALTER command allows you to change almost everything in your table without having  to reinsert data. But if you change type of the column to different one, you risk losing  your data.  ALTER TABLE can help you only to improve your table design, nothing more.- Use RENAMEALTER TABLE projects RENAME TO project_list;
- Use CHANGE - modify both the name and data type of an existing columnALTER TABLE project_list
  CHANGE COLUMN number proj_id INT NOT NULL AUTO_INCREMENT,
  ADD PRIMARY KEY ('proj_id');
You can change more than one column in a single statement.- Use MODIFY - modify the data type or position of an existing columnALTER TABLE project_list
  MODIFY COLUMN proj_desc VARCHAR(120);
- Use ADD - add a column to your table - you pick the data typeALTER TABLE my_contacts
  ADD COLUMN contact_id INT NOT NULL AUTO_INCREMENT FIRST,
  ADD PRIMARY KEY (contact_id);
FIRST says that the column will be first in the table. Also you can use: AFTER your_column,  BEFORE your_column, SECOND, THIRD and you get the idea ;)- Use DROP - drops a column from your tableALTER TABLE project_table
  DROP COLUMN start_date;
Once you've dropped a column, everything that was stored in it is removed too!    TIP: Use SELECT first to see data that you intend to drop.7 Advanced SELECT ~~~~~~~~~~~~~~~~~~~~~~7.1 CASE =========   The CASE expression combines all the UPDATE statements by checking an existing column's   value against a condition.UPDATE my_table
  SET new_column =
  CASE
  WHEN column1 = somevalue1
  THEN newvalue1
  WHEN column2 = somevalue2
  THEN newvalue2
  ELSE newvalue3
  END;
Order matters! Also you can use all ADD and OR combinations in WHEN clause.7.2 ORDER BY =============   If you want to order your query then try ORDER BY. ORDER BY allows you to alphabetically   order any column.SELECT
  ....
  ORDER BY column_name;
It is possible to order by two columns. Better, you can sort by as many columns as you need.   Example:SELECT * FROM movie_table
  ORDER BY category, purchased, title;
Order by category, then for a particular category order by purchased, and then for a particular purchased film order by title.   (category (purchased (title)))   Use keyword DESC after your column name in ORDER BY clause to reverse the order of you results.7.3 GROUP BY =============SELECT first_name, SUM(sales)
  FROM cookie_sales
  GROUP BY first_name
  ORDER BY SUM(sales) DESC;
Group together all the first_name values. Imagine that GROUP BY divide the table for every   first_name and then pass every table to the SUM function(see below).   In this way for every name we have the total sales (sum of all sales) from high-to-low.   TIP: Using GROUP BY combines the duplicates into one single value for each group. But be careful this will not work for   tables like this     Interests         --------------     books, sport       pets, books      *(Hint: Use joins)*7.4 SQL functions ==================   SQL language has some special keywords called functions. Each function is a bit a code   that preform an operation on a value or values.7.4.1 SUM ----------SELECT SUM(sales)
  FROM cookie_sales
  WHERE first_name = 'Nicole';
SUM function totals the values in the sales column.7.4.2 AVG, MIN, MAX, COUNT ---------------------------    COUNT will return the number of rows in a column - single numberSELECT COUNT(*)
  FROM Student;
Return the number of rows in a table.7.5 SELECT DISTINCT ====================SELECT COUNT(DISTINCT sale_data)
  FROM cookie_sales;
Result will be one row because of the COUNT.   DISTINCT is a keyword.7.6 LIMIT ==========   Limits the number of results. Also possibleLIMIT 2
  LIMIT 0,4
  LIMIT 1,1
8 Multi-table database design ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  TIP: Your table design should do the heavy lifting for you. Don't write convoluted queries  to "get around" a badly designed table. Ignoring the problem isn't the answer.  We need to thing outside of a single table. How to add another table?  TIP: We need to move the non-atomic columns in our table into new tables!  A description of the data (the columns and tables) in your database, along with any other related  objects and the way they all connected in known as a SCHEMA.  TIP: Creating a diagram of your table lets you keep the design of the table separate from  the data that's inside of it.  How to go from one table to two? Here is the algorithm:  - Remove the column and put it in its own table  - Add columns that will let us identify it.    Example:      my_contacts              interests     -----------------       -----------------      contact_id(pk)           int_id(pk)      last_name                last_name      first_name               first_name                               interests    How to connect tables? 'first_name' and 'last_name' combination is not unique!          my_contacts              interests     -----------------       -----------------      contact_id(pk)           int_id(pk)      last_name                interests      first_name               contact_id(fk)    contact_id in interest table is foreign key!    The FOREIGN KEY is a column in a table that references the PRIMARY KEY of another table!    'contact_id' is unique so we know the reference.    Foreign key facts:  1. A foreign key can have a different name than the primary key it comes from.  2. The primary key used by a foreign key is also known as a PARENT KEY. The table where the     primary key is from is known as a parent table.    3. The foreign key can be used to make sure that the rows in one table have corresponding rows     in another table.    4. Foreign key values can be null, even though primary key values can't.    5. Foreign keys don't have to be unique - in fact, they often aren't.A NULL foreign key means that there's no matching primary key in the parent table!But we can make sure that a foreign key contains a meaningful value, one that exist in the parent table,by using a CONSTRAINT.Constraint defines rules for relation. Creating a foreign key as a constraint in your table gives youdefinite advantages. You'll get errors if you violate the rules, which will stop you accidentallydoing anything to break the table.Referential integrity: You will only be able to insert values into your foreign key that existin the table the key came from, the parent table.TIP: You can use a foreign key to reference a unique value in the parent table. It doesn't haveto be the primary key of the parent table, but it must be unique.TIP: Foreign key could be added with ALTER TABLE.Example:CREATE TABLE interests
  (
      int_id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
      interest VARCHAR(50) NOT NULL,
      contact_id INT NOT NULL,
      CONSTRAINT my_contacts_contact_id_FK
      FOREIGN KEY (contact_id)
      REFERENCES my_contacts (contact_id);
  )
TIP: How to form constraint names? parent_table_foreign_key_name>_FKThere is many types of relation.8.1 ONE-TO-ONE ===============   One-To-One: exactly one row of a parent table is related to one row of a child table.   We used if for example we would like to isolate some data from the parent table.   Advantages:   - Pulling the data out may allow you to write faster queries.   - If you have a column containing values you don't yet know,   you can isolate it and avoid NULL values in your main table.   - You may wish to make some of your data less accessible.   - If you have a large piece of data, a BLOB type for example,   you may want that large data in a separate table.8.2 ONE-TO-MANY ================   One-to-many: a record in Table A can have MANY matching records in Table B, but a record in Table B   can only match ONE record in Table A.8.3 MANY-TO-MANY =================   Unacceptable! How to fix that?   We need a table to step in between these two many-to-many tables and simplify the relationship to one-to-many.   We need what is called a JUNCTION TABLE, which contain the primary key columns of the two tables we want to relate.   In this way we have tow one-to-many relationships.   When a column's data must change when another column's data is modified, the first column   is functionally dependent on the second.   For example if we have table Person with columns name and initials. Initials column is functional dependent   on column name. We say that column initials is dependent column.   A partial functional dependency means that a non-key column is dependent on some, but not all,   of the columns in a composite primary key.   If in table Person, primary key is SSN and name, initials is partially dependent on name.   If changing any of the non-key columns might cause any of the other columns to change,   you have a transitive dependency.   You can say: when any non-key column is related to any of the other non-key columns.   But how to avoid partial dependency?   One simple way is to use ID for a primary key. Adding primary key columns to our tables is   helping us achieve 2NF, because the second normal form focuses on how the primary key in a   table relates to data in it.   Your 1NF table is also 2NF if all the columns in table are part of the primary key OR it has   a single column primary key. More strictly here is the rules:   Rule 1: Be in 1NF   Rule 2: Have no partial functional dependencies.   Tip: Any table with an artificial primary key and no composite primary key is always 2NF.   Third Normal Form or 3NF:   Rule 1: Be in 2NF   Rule 2: Have no transitive dependencies   Practical rule for decomposition to 3NF:If A is in functional dependency with B then A is a key in decomposed tables!Example:table Apply(SSN, Student_Name, Collage_Name)SSN is in functional dependency with Student_Name => Create two tables with key SSN, table Student(SSN, Student_Name)and table Apply(SSN, Collage_Name).Nirvana, or what is 4NF   Forth Normal Form or 4NF:   Rule 1: Be in 3NF   Rule 2: Have no multivalued dependenciesLet's explain this with example. Imagen that you have table Apply(SSN, Student_Name, High_School).It is in 3NF because there is no functional dependencies, but SSN is in multivalued dependencies with Student_Nameand High_School because it is a key for every Student_Name and High_School combination (Student_Name*High_School - number of conbinations).Practical rule for decomposition to 4NF:If A is in multivalued dependency with B and C then A is a key in decomposed tables!Example:table Apply(SSN, Student_Name, High_School)SSN is in multivalued dependency with Student_Name and High_School => Create two tables with key SSN, table Apply(SSN, Student_Name)and table HighSchool(SSN, High_School).9 Start with joins ~~~~~~~~~~~~~~~~~~~~~~~  Because now we have many table and all the information is spread. Using joins we can collect data  easily.9.1 AS =======  Variant 1:CREATE TABLE profession
  (
  id INT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY,
  profession VARCHAR(20)
  ) AS
  SELECT profession FROM my_contacts
  GROUP BY profession
  ORDER BY profession;
Variant 2:CREATE TABLE profession AS
  SELECT profession FROM my_contacts
  GROUP BY profession
  ORDER BY profession;
ALTER TABLE profession
  ADD COLUMN  id INT(11) NOT NULL AUTO_INCREMENT FIRST,
  ADD PRIMARY KEY (id);
In both variants AS is used to references result of a query. It is used also for   name aliases.CREATE TABLE profession
  (
  id INT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY,
  profession VARCHAR(20)
  ) AS
  SELECT profession AS mc_prof FROM my_contacts
  GROUP BY mc_prof
  ORDER BY mc_prof;
The alias change the name of the column in result but doesn't change the original   column name in any way. An alias is temporary! Table aliases are also called correlation names.   They are very useful in long queries.  TIP: Some time we can alias without AS:SELECT profession mc_prof
  FROM my_contacts mc
  GROUP BY mc_prof
  ORDER BY mc_prof;
Before we start with joins, let's define simplest join called - Cartesian join, Cartesian product,   cross product. It means join all!   Toys table                             Boys table     toy_id      toy                  boy_id    boy    ---------+----------------      ---------+----------------           1   hula hoop                   1   Zlatko           2   balsa glider                2   Mitko           5   baseball cards     The CROSS JOIN returns every row from one table crossed with every row from secondSELECT t.toy, b.boy
  FROM toys AS t
  CROSS JOIN boys AS b;
(or you can just write: SELECT toys.toy, boys.boy FROM toys, boys;)   This join get number of toys multiplied by numbers of boys to account for every possible combination.   TIP: Using CROSS JOIN by mistake you can hanging your machine.   But why we need CROSS JOIN? Answer is simple, to understand better INNER JOIN.   An INNER JOIN is a CROSS JOIN with some result rows removed by a condition in a query.   Here is the syntax:SELECT some_columns
  FROM table1
  INNER JOIN
  table2
  ON some_condition;
An INNER JOIN combines the records from two tables using comparison operators in a condition.9.2 EQUIJOIN =============   This is a inner joins test for equality.SELECT t.toy, b.boy
  FROM boys
  INNER JOIN
  toys
  ON boys.toy_id = toys.toy_id;
9.3 NON-EQUIJOIN =================SELECT t.toy, b.boy
  FROM boys
  INNER JOIN
  toys
  ON boys.toy_id <> toys.toy_id
  ORDER BY boys.boy;
9.4 NATURAL JOIN =================   Natural joins only work if the column you're joining by has the same name in both tables.   Toys table                                     Boys table     toy_id      toy                            toy_id       boy    ---------+----------------                ---------+----------------           1   hula hoop                             1   Zlatko           2   balsa glider                          2   Mitko           5   baseball cards  SELECT boys.boy, toys.toy,
  FROM boys
  NATURAL JOIN
  toys;
This two tables are joined on 'toy_id' column.   Natural join inner joins identify matching column names.   TIP: You can join more than one table   The same effect you can achieve using query inside a query - subqueries!10 SUB-QUERIES ~~~~~~~~~~~~~~~~~~~  Simple data base to illustrate the queries:  [Simple database] 
A subquery is a query that is wrapped within another query. It's also called an INNER query.  Subquery is nothing more than a query inside another query. The outside query is known as  containing query, or outer query. The query on the inside is the inner query, or subquery.  Example 1:SELECT some_column, another_column
  FROM table
  WHERE column = (SELECT column FROM table);
Because it use the = operator, this subquery will return a single value, one row from one column  (sometimes called a cell, but in SQL known as a scalar value), which is compared to the  columns in the WHERE clause. If it returns more you'll get an error.  Example 2: JOINS <=> SUBQUERYSSELECT last_name, first_name
  FROM my_contacts
  WHERE zip_code = (SELECT zip_code FROM
  zip_code WHERE city = 'Memphis' AND state = 'TN');
is equivalent to:SELECT last_name, first_name
  FROM my_contacts mc
  NATURAL JOIN zip_code zc
  WHERE zc.city = 'Memphis' AND zc.state = 'TN';
TIP: Joins are faster, subquerys are more readable.  Because subquerys are very verbose it is a good idea to use aliases - column aliases.  Example:SELECT mc.first_name AS firstname, mc.last_name AS lastname,
  mc.phone AS phone, jc.title AS jobtitle
  FROM job_current AS jc
  NATURAL JOIN my_contacts AS mc
  WHERE jobtitle IN (SELECT title FROM job_listings);
The tricky part about subqueries isn't the structure; it's figuring out what part of  the query needs to be the subquery. Or even if you need one at all.  Example:  Who make the most money out of all of my contacts?- Identify a query that answers part of the question.SELECT MAX(salary) FROM job_current;
- Continue dissecting your query. We need to select names.SELECT mc.first_name, mc.last_name
  FROM my_contacts AS mc;
- Finally, figure out how to link the two.SELECT mc.first_name, mc.last_name, jc.salary
  FROM my_contacts AS mc
  NATURAL JOIN job_current AS jc;
- And now add the WHERE clause to link the twoSELECT mc.first_name, mc.last_name, jc.salary FROM my_contacts AS mc
  NATURAL JOIN job_current AS jc
  WHERE jc.salary = (SELECT MAX(jc.salary) FROM job_current jc);
If a subquery is used as a column expression in a SELECT statement, it can only return one value from one column.SELECT mc.first_name, mc.last_name,
  (SELECT state FROM zip_code WHERE mc.zip_code = zip_code) AS state
  FROM my_contacts mc;
If the subquery stands alone and doesn't reference anything form the outerquery, it is a noncorrelated subquery.SELECT mc.first_name, mc.last_name, jc.salary
  FROM my_contacts AS mc
  NATURAL JOIN job_current AS jc
  WHERE jc.salary > (SELECT jc.salary
                  FROM my_contacts mc NATURAL JOIN job_current jc
                  WHERE email = 'some@somedomain.com");
In noncorrelated subquery you can use IN or NOT IN to test if the values returned in thesubquery are members of a set (or not). This is possible because noncorrelated subqueries could return more than one column.SELECT mc.first_name, mc.last_name, mc.phone, jc.title
  FROM job_current jc
  NATURAL JOIN my_contacts mc
  WHERE jc.title NOT IN (SELECT title FROM job_listings);
A very common use for correlated subqueries is to find all the rows in the outer queryfor which no rows exist in a related table:SELECT mc.first_name firstname, mc.last_name lastname, mc.email email
  FROM my_contacts mc
  WHERE NOT EXIST
  (SELECT * FROM job_current jc
  WHERE mc.contact_id = jc.contact_id);
NOT EXIST finds the first and last names and so on form 'my_contacts' table who are notcurrently listed in the 'job_current' table.TIP: You can use just EXISTWhat is the best approach when trying to construct a subquery inside a subquery?Your best bet is to write little queries for the various parts of the question. Thenlook at them and see how you need to combine them.Also correlated subqueries exist! A correlated subquery means that the inner query relieson the outer query before it can be resolved.Example:  People how have three interests.SELECT mc.first_name, mc.last_name
  FROM my_contacts AS mc
  WHERE 3 = (
           SELECT COUNT(*) FROM contact_interest
           WHERE contact_id = mc.contact_id
           );
The outer query has to be executed before we know what the value of 'mc.contact_id' is!Inner query uses the same aliases or correlation name for 'my_contacts'. mc that was created in the outer query.11 Outer joins, self-joins, and unions ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  With an inner join, you're comparing rows from two table, but the order of those  two tables doesn't matter. Outer joins have more to do with the relationship between  two tables than the inner joins.  The LEFT OUTER JOIN takes all the rows in the left table and maches them to rows  in the left table and matches them to rows in the right table. It is useful when the  left table and the right table have a one-to-many relationship.  The left outer join matches EVERY ROW in the LEFT table with a row from the right table.  The big secret to understanding an outer join is to know which table is on the left and which is  on the right.SELECT t1.column, t2.column
  FROM table1 t1
  LEFT OUTER JOIN table2 t2
  ON t1.table_id = t2.table_id;
table1 is the LEFT, table2 is RIGHT. So LEFT table will "say" how many columns result table will have.  The big difference is that an outer join gives you a row whether there's a match with the other  table or not! So then, a NULL value in the results of a left outer join means that the right table  ha NO VALUES that corresponding to the left tables.  The same with the RIGHT OUTER JOIN. The right outer join evaluates the right table against the left  table.  TIP: It will be easier to always stick with one, say the left outer join.  You can use the same table as both the right and the left table in an outer join - self-join!  But when it will be handy?  A SELF-REFERENCING foreign key is the primary key of a table used in that same table for another purpose.  The self-referencing part means that it is a key that is referencing another field in the same table.  In tables where we have self-referencing we can use self-join. In this way we simulate having two tables.  The self-join allows you to query a single table as though there were two tables with exactly the  same information in them.11.1 Unions ============   Except JOINS and SUBQUERIES there is another way to get multi-table information - UNIONS.   UNION combines the results of two or more queries into one table, based on what you specify in the   list of the SELECT.   Example:SELECT title FROM job_current
  UNION
  SELECT title FROM job_desired
  UNION
  SELECT title FROM job_available;
UNION can take one ORDER BY at the end of the statement. This is because UNION concatenates and   groups the results from the multiple SELECT statements.SELECT title FROM job_current
  UNION
  SELECT title FROM job_desired
  ORDER BY title;
Remember that the number of columns in each SELECT statement must match. Also UNION suppresses all   duplicate values from results. If you DO want to see duplicate, you can use operator UNION ALL!SELECT title FROM job_current
  UNION ALL
  SELECT title FROM job_desired
  ORDER BY title;
More useful example:CREATE TABLE my_union AS
  SELECT title FROM job_current
  UNION
  SELECT title FROM job_desired;
11.2 INTERSECT and EXCEPT ==========================   INTERSECT and EXCEPT are used in much the same way as UNION - to find parts of queries that overlap.   INTERSECT returns only those columns that are in the first query and also in the second query.   EXCEPT returns only those columns that are in the first query, but NOT in the second query.   TIP: This two operations DO NOT EXIST in MySQL.   TIP: It is a good practice to be consistent. Subqueries and joins are equivalent and if you have started using joins, used all the time. The same is for subqueries usage.   Using joins and subqueries for self-join   - JoinSELECT c1.name, c2.name AS boss
  FROM person_info c1
  INNER JOIN person_info c2
  ON c1.boss_id = c2.id;
- SubqueriesSELECT c1.name,
  (SELECT name FROM person_info
  WHERE c1.boss_id = id) AS boss
  FROM person_info c1;
11.3 A Visual Explanation of SQL Joins =======================================Assume we have the following two tables. Table A is on the left, and Table B is on the right. We'll populate them with four records each.  id name               id  name  -- ----               --  ----  1  Pirate      1   Rutabaga  2  Monkey             2   Pirate  3  Ninja        3   Darth Vader  4  Spaghetti          4   NinjaLet's join these tables by the name field in a few different ways and see if we can get a conceptual match to those nifty Venn diagrams. SELECT * FROM TableA
  INNER JOIN TableB
  ON TableA.name = TableB.name
[Inner Join]
id  name       id   name  --  ----       --   ----  1   Pirate     2    Pirate  3   Ninja      4    NinjaInner join produces only the set of records that match in both Table A and Table B.SELECT * FROM TableA
  FULL OUTER JOIN TableB
  ON TableA.name = TableB.name
id    name            id    name  --    ----            --    ----  1     Pirate          2     Pirate  2     Monkey          null  null  3     Ninja           4     Ninja  4     Spaghetti       null  null  null  null            1     Rutabaga         null  null            3     Darth Vader[Full Outer Join]
Full outer join produces the set of all records in Table A and Table B, with matching records from both sides where available.If there is no match, the missing side will contain null.SELECT * FROM TableA
  LEFT OUTER JOIN TableB
  ON TableA.name = TableB.name
id  name             id    name  --  ----             --    ----  1   Pirate           2     Pirate  2   Monkey           null  null  3   Ninja            4     Ninja  4   Spaghetti        null  null[Left Outer Join]
Left outer join produces a complete set of records from Table A, with the matching records (where available) in Table B.If there is no match, the right side will contain null.SELECT * FROM TableA
  LEFT OUTER JOIN TableB
  ON TableA.name = TableB.name
  WHERE TableB.id IS null
id  name            id     name  --  ----            --     ----  2   Monkey          null   null  4   Spaghetti       null   null[Exclude Right Side]
To produce the set of records only in Table A, but not in Table B, we perform the same left outer join, then exclude the records we don't want from the right side via a where clause.SELECT * FROM TableA
  FULL OUTER JOIN TableB
  ON TableA.name = TableB.name
  WHERE TableA.id IS null 
  OR TableB.id IS null
id    name          id    name  --    ----          --    ----  2     Monkey        null  null  4     Spaghetti     null  null  null  null          1     Rutabaga  null  null          3     Darth Vader[Exclude Both Sides]
To produce the set of records unique to Table A and Table B, we perform the same full outer join, then exclude the records we don't want from both sides via a where clause.There's also a cartesian product or cross join, which as far as I can tell, can't be expressed as a Venn diagram:SELECT * FROM TableA
  CROSS JOIN TableB
This joins "everything to everything", resulting in 4 x 4 = 16 rows, far more than we had in the original sets. If you do the math, you can see why this is a very dangerous join to run against large tables.12 Constraints, views, and transactions ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~12.1 Adding CHECK CONSTRAINT =============================   A constraint is a restriction on what you can insert into a column. Constraints are added when we   create a table. Some of the constraints we've already seen include NOT   NULL, PRIMARY KEY, FOREIGN KEY, and UNIQUE.      There's another sort of column constraint, called a CHECK.      A CHECK constraint restrict what values you can insert into a column. It uses the same conditionals as WHERE clause.   Example:CREATE TABLE piggy_bank
  (
      id INT AUTO_INCREMENT NOT NULL PRIMARY KEY,
      coin CHAR(1) CHECK (coin IN ('P', 'N', 'D', 'Q'))
  )
If the value you're trying to insert fails the CHECK condition, you get an error.   TIP: CHECK doesn't enforce data integrity in MySQL. In MySQL you can work around it with triggers.12.2 Views ===========   If you have a long an complex query that you have to run constantly you can crate a view. Creating   view is really simple:CREATE VIEW web_designers AS
  SELECT mc.first_name, mc_last_name, mc_phone
  FROM my_contacts mc
  NATURAL JOIN job_desired jd
  WHERE jd.title = 'Web Designer';
Instead of CREATE TABLE you write CREATE VIEW. Then you treat is as table:SELECT * FROM web_designers;
TIP: When you actually use your view in a query, it's behaving as though it were a subquery.   Let's dissect SELECT query. What it says is "Select everything from the subquery that returns the   first/last name and phone of all the people from 'my_contacts' who are looking for a job as web designer". In code this looks like this:SELECT * FROM (SELECT mc.first_name, mc.last_name, mc.phone
                FROM my_contacts mc
                NATURAL JOIN job_desired jd
                WHERE jd.title = 'Web Designer') AS web_designers;
(We gave a name to our subquery - web_designers)   A VIEW is basically a table that only exist when you use the view in a query. It's considered a   virtual table because it acts like a table, and some operations that can be performed on a table   can be preformed on a view.   TIP: Virtual table doesn't stay in the database. It gets created when we use the view and then deleted.   Why views are good for your database?   1. You can keep changes to your database structure from breaking applications that depend on your tables.   2. Views make your life easier bey simplifying you complex query into a simple command.   3. You can create views that hide information that isn't needed by the user.Is it possible to inserting, updating, and deleting with views?Yes, but it depends. If your view used aggregate values (like SUM, COUNT, and AVG), you won't beable to use it to change data. Also, if your view contains GROUP BY, DISTINCT, or HAVING, it won'tchange data either. Most of the time it might be easier to INSERT, UPDATE, and DELETE the old-fashioned way.TIP: CHECK OPERATION checks each query you try to INSERT or UPDATE to see if it's allowed according to the   WHERE clause in your viewAn updatable view is a view that allows you to change the underlying tables. The important pointhere is that an updatable view includes all the NOT NULL columns form the tables it references.That way, when you INSERT using view, you can be certain that you will have a value for every columnyou required to have a value in. The opposite for non-updatable views, it includes all the NOT NULLcolumns.When you're finished with your view, just drop it.DROP VIEW view_name;
TIP: CHECK constraints and views both help maintain control when you have multiple users.12.3 Transaction =================   A transaction is a set of SQL statements that accomplish a single unit of work.   During a transaction, if all the steps can't be completed without interference, none of them   should be completed.   What is ACID?   Atomicity: All of the pieces of the transaction must be completed, or none of them will be completed.   Consistency: A complete transaction leaves the database in a consistent state at the end of the transaction.   Isolation: It means that every transaction has a consistent view of the database regardless of other   transactions taking place at the same time.   Durability: After the transaction, the database needs to save the data correctly and protect it   from power outages or other threads.   Example:START TRANSACTION;
  ........
  /* START TRANSACTION keeps track of all the SQL that follows until you enter either
  COMMIT or ROLLBACK */
  .......
  COMMIT;
TIP: No changes will occur to the database until you COMMIT.   What is storage engine?   Storage engine is the behind-the-scenes structure that stores all your database data and structures.   Some types allows transaction; some types do not, but they are faster.      TIP: For MySQL you need make sure your storage engine is either BDB of InnoDB, the two choices      that support transactions.      RDBMS keeps a record of everything that has been done when you are inside a transaction. It's   called transaction log, and it keeps getting bigger and bigger the more you do in transaction.   It's best to save using transactions for when you really need to be able to undo what you're   doing to avoid wasting space and making your RDBMS faster.13 Security ~~~~~~~~~~~~~~~~~  See your database documentation.  TIP: You can control exactly what users can do to tables and columns with the GRANT statement.  Example:GRANT SELECT ON my_contacts TO programmer;
If you decide to remove privilege you need REVOKE.  Example:REVOKE SELECT ON my_contacts FROM programmer;
There is a lot details here but they are more for database administrators, that's why we just skip them.

Advanced Emacs Commands

2011-03-02T18:59:00.004+02:00

Common default Emacs key prefixes
Key prefix Description
C-c Commands particular to the current editing mode
C-x Commands for files and buffers
C-h Help commands
M-x Literal function name
C-h b Show key bindings

Emacs window-manipulation commands
Key Function Description
C-x 4 f find-file-other-window Open a new file in a new buffer, drawing it in a new vertical
window.

undefined scroll-all-mode Toggle the scroll-all minor mode. When it's on, all windows
displaying the buffer in the current window are scrolled
simultaneously and in equal, relative amounts.

C-x 3 split-window-horizontally Split the current window in half down the middle, stacking the new
buffers horizontally.

undefined follow-mode Toggle follow, a minor mode. When it's on in a buffer, all windows
displaying the buffer are connected into a large virtual window.

C-x ^ enlarge-window Make the current window taller by a line; preceded by a negative,
this makes the current window shorter by a line.

C-x } shrink-window-horizontally Make the current active window thinner by a single column.

C-x { enlarge-window-horizontally Make the current active window wider by a single column.

C-x - shrink-window-if-larger-than-buffer Reduce the current active window to the smallest possible size for
the buffer it contains.

C-x + balance-windows Balance the size of all windows, making them approximately equal.

undefined compare-windows Compare the current window with the next window, beginning with
point in both windows and moving point in both buffers to the
first character that differs until reaching the end of the buffer.

Emacs text manipulation commands
Key Function Description
C-x Tab indent-rigidly This command indents lines in the region (or at point).

undefined fill-region This command fills all paragraphs in the region.

M-q fill-paragraph This command fills the single paragraph at point.

M-\ delete-horizontal-space This command removes any horizontal space to the right and left of
point.

C-o open-line This command opens a new line of vertical space below point,
without moving point.

C-t transpose-chars This command transposes the single characters to the right and
left of point.

M-t transpose-words This command transposes the single words to the right and left of
point.

C-x C-t transpose-lines This command transposes the line at point with the line before it.

M-^ delete-indentation This command joins the line at point with the previous line.
Preface with C-1 to join the line at point with the next line (C-1 M-^)

M-u uppercase-word This command converts the text at point to the end of the word to
uppercase letters.

M-l downcase-word This command converts the text at point to the end of the word to
lowercase letters.

C-x C-l downcase-region This command converts the region to lowercase letters.

C-x C-u upcase-region This command converts the region to uppercase letters.

M-m back-to-indentation This command, given anywhere on a line, positions point at the
first non blank character on the line.

C-s C-w This command, add the (rest of the) word at the pointer for search

Emacs commands for using registers
Emacs registers are general-purpose storage mechanisms that can store one of many things, including text,
a rectangle, a position in a buffer, or some other value or setting. Every register has a label, which is
a single character that you use to reference it.

A register can be redefined, but it can contain only one thing at a time. Once you exit Emacs, all registers
are cleared.

Key Function Description
C-x r space X point-to-register Save point to register named X.

C-x r s X copy-to-register Save the region to register named X.

C-x r r X copy-rectangle-to-register Save the selected rectangle to register named X.

undefined view-register View the contents of a given register.

C-x r j X jump-to-register Move point to the location given in register named X.

C-x r i X insert-register Insert the contents of register named X at point.

Emacs commands for using bookmarks
Emacs has another facility for saving positions in buffers. These Emacs bookmarks work the same as registers,
but their labels can be longer than a single character, and they're more permanent: If you save them, you
can use them between sessions. They persist until you remove them. As their name implies, bookmarks are
handy for saving your position in a buffer so that you can return to it at a later time, most often during a
later Emacs session.

Key Function Description
C-x r m Bookmark bookmark-set Set a bookmark named Bookmark.

C-x r l bookmarks-bmenu-list List all saved bookmarks.

undefined bookmark-delete Delete a bookmark.

C-x r b Bookmark bookmark-jump Jump to the location set in the bookmark named Bookmark.

undefined bookmark-save Save all bookmarks to the bookmark file, ~/.emacs.bmk.
(you can redefine it)

Emacs commands for using rectangles
Did you ever wish you could select a box of text from a document for copying, killing, or yanking purposes?
You can. In Emacs, a selection of text specified by any two opposite of its four corners is called a rectangle.

Key Function Description
C-space set-mark-command Marks one corner of a rectangle (point marks the opposite corner).

C-x r k kill-rectangle Kills the current rectangle and saves it in a special rectangle
buffer.

C-x r d delete-rectangle Deletes the current rectangle and doesn't save it for yanking.

C-x r c clear-rectangle Clears the current rectangle, replacing the entire
area with whitespace.

C-x r o open-rectangle Opens the current rectangle, filling the entire area with
whitespace and moving all text from the rectangle to the right.

C-x r y yank-rectangle Yanks the contents of the last-killed rectangle at point, moving
all existing text to the right.

Mark rings
You should never have to scroll around randomly in a buffer to find "that place you were just looking at".
Whenever you take a diversion (e.g. by searching, or pressing M-< or M->), Emacs uses the mark to save
your previous position, kind of like sticking your finger behind one page of a book while you go to glance at
another page. You can return to the mark with C-x C-x.

However, Emacs saves up to 16 previous values of the mark, and you can jump to previous ones with C-u C-SPC.
This makes mark and the mark ring a valuable navigation tool. You can use it somewhat mindlessly:
if you ever find yourself asking "where was I just now?" you can often just press C-u C-SPC until you
find yourself back in the right place.

Programming
Key Function Description
M-x check-parens Checking for unmatched parentheses
C-x w h REGEXP FACE Highlight matches of pattern REGEXP in current buffer with FACE.

C-x w p PHRASE FACE Highlight matches of phrase PHRASE in current buffer with FACE.
(PHRASE can be any REGEXP, but spaces will be replaced by matches
to whitespace and initial lower-case letters will become case
insensitive.)

C-x w l REGEXP FACE Highlight lines containing matches of REGEXP in current buffer
with FACE.

C-x w r REGEX Remove highlighting on matches of REGEXP in current buffer

Tips:
C-SPC Make mark in some place and then disable it with C-g
Go somewhere else and do it again and again etc.
C-u C-SPC Back to previous mark, and back and back etc.

Highlighting Regexps, Phrases, And Lines
Key Function Description
M-s h p highlight-phrase It will ask you for a phrase and highlighting color and then highlight
all the matching phrases in the buffer.
M-s h r highlight-regexp Highlight anything that matches an arbitrary regexp
M-s h l highlight-lines-matching-regexp Highlights the entire line that contains the match to the regular expression
M-s h u unhighlight-regexp Un-highlight the matches

Useful references:
Beyond Emacs Tutorial
Reference Card

Mercurial for team members collaboration

2011-02-25T12:32:00.014+02:00

В моя екип често се налага да се работи от двама или трима за реализация на нова фукционалност.

Фирмата политика е да се ползва Subversion, така че за да се обмени временен код е необходимо
да се миние през "централния" Subversion, да се обменят файлове или patches.
Това може и да сработи ако са двама човека, но става много по-трудно ако са повече. Да не говорим, че по този начин много лесно се пополират бъгове.
Затова погледахме към дистрибутивните системи за версии (DVCS), каквито са Git и Mercurial.
Каква ни беше целта?

1. Лесно да обменяме промени в кода.
2. Лесно да поправяме кода на другия
3. Лесен merge
4. Работа от вкъщи
5. В Subversion да отиват само неща, които са напълно завършени.
6. QA екипа да може да взема временен код от всеки от нас.


Да, това е възможно. Mercurial ни се видя по-интуитивен и затова избрахме него.
Ето и инфраструктурата, която направихме.

1. Направихме клон на Subversion проекта с hgsubversion и го кръстихме Develop

На определен за целта сървър инсталираме Mercurial и правим потребител с това име.
В неговата директория .hgrc конфигурирана ето така:
[ui]
username = Mercurial Administrator  (mercurial@example.com)
merge = internal:merge

[auth]
project.prefix = url to Subversion repository
project.username = subversion user name
project.password = subversion user password

[web]
contact = develop_admin@example.com
description = Develop Mercurial Repository
style = gitweb
allow_archive = bz2 gz
allow_push = *
push_ssl = false

[alias]
tip = log -r tip
. = summary

[extensions]
pretxnchangegroup.forbid_2heads = path to where "forbid_2head.py" is located
fetch =
rebase =
bookmarks =
progress =
color =
hgext.mq =
hgext.extdiff =
hgext.graphlog =
hgsubversion = path to where hgsubversion was build

[defaults]
diff = --unified 5
cdiff = -q
commit = -v

[diff]
git=True
showfunc = 1
unified = 8

[extdiff]
cmd.cdiff = colordiff
opts.cdiff = -uprN

[bookmarks]
track.current = True

[hooks]
changegroup=hg diff --stat -r $HG_NODE -r tip
# Prevent "hg pull" if MQ patches are applied.
prechangegroup.mq-no-pull = ! hg qtop > /dev/null 2>&1
# Prevent "hg push" if MQ patches are applied.
preoutgoing.mq-no-push = ! hg qtop > /dev/null 2>&1
# Prevent "hg update" if MQ patches are applied.
preupdate.mq-no-update = ! hg qtop > /dev/null 2>&1
Няколко неща трябва да бъдат инсталирани - colordiff и hgsubversion. За да "сервира" нещата не използаме вградения сервер в Mercurial, а пускаме Apache. Подобна конфигурация може да видите тукКартинката изглежда ето така:
Master всъшност е Subversion trunk. По този начин избягваме неприятнатa операция mergeпрез Subversion. От тук нататък всичко става в Mercurial и само готови и проверени неща отиват в Subversion. Много много важно нещо да не забравя да кажа - Master  не трябва да има "разклонения" т.е. трябва да се забрани "dual head". За целта слагаме "forbid_2head.py"2. Всеки от екипа прави клониниг от DevelopЕто как изглежда работата ни:
За целта всеки от нас си настройва локален Mercurial сървър.[ui]
username = zlatozar (zlatozar@example.com)

[alias]
tip = log -r tip
. = summary
, = glog -l15 --template '\033[33;40m{rev} \033[37;40m{desc|firstline|fill68} \033[1;30;40m({date|age} by {author|person})\033[0;37;40m \033[33;40m{tags}\033[37;40m \033[35;40m{branches}\033[37;40m\n\n'

[web]
contact = zlatozar@example.com
description = Zlatozar's Public Repository
style = gitweb
#allow_push = *
push_ssl = false
allow_archive = bz2 gz

[extensions]
fetch =
rebase =
bookmarks =
progress =
color =
hgext.mq =
hgext.extdiff =
hgext.graphlog =

[defaults]
diff = --unified 5
cdiff = -q
commit = -v

[diff]
git=True
showfunc = 1
unified = 8

[extdiff]
cmd.kdiff3 =

[bookmarks]
track.current = True

[merge-tools]
kdiff3.args = $base $local $other -o $output

[hooks]
changegroup=hg diff --stat -r $HG_NODE -r tip
# Prevent "hg pull" if MQ patches are applied.
prechangegroup.mq-no-pull = ! hg qtop > /dev/null 2>&1
# Prevent "hg push" if MQ patches are applied.
preoutgoing.mq-no-push = ! hg qtop > /dev/null 2>&1
# Prevent "hg update" if MQ patches are applied.
preupdate.mq-no-update = ! hg qtop > /dev/null 2>&1
На локалната машина трябва да се инсталира - mercurial, colordiff и kdiff3.3. Всеки от екипа има публично хранилище, от което може да се вземат промените.Скрипта, с който всеки си пуска сървъра е следния:#!/bin/sh
#
# Startup script for local mercurial server
#
APP_BIN=/usr/bin/hg

#
# Change following lines
#
SRC=path to cloned Develop repository that user works on
SRCNAME="project name (Zlatozar's repository)"

# Path to PID file of running mercurial process.
PID_FILE=${SRC}/hg.pid

state=$1
case "$state" in
    'start')
        echo "Mecurial Server service starting..."
        (cd ${SRC} ;${APP_BIN} serve --name "${SRCNAME}"  -d  -p 1111 --pid-file ${PID_FILE})
        ;;

    'stop')
        if [ -f "${PID_FILE}" ]; then
            PID=`cat "${PID_FILE}"`
            if [ "${PID}" -gt 1 ]; then
                kill -TERM ${PID}
                echo "Stopping the Mercurial service PID=${PID}."
            else
                echo Bad PID for Mercurial -- \"${PID}\"
            fi
        else
            echo No PID file recorded for mercurial
        fi
        ;;

    *)
        echo "$0 {start|stop}"
        exit 1
        ;;
esac
Уговорката е локалния Mercurial да е на порт 1111. Забележка:Тук може да има проблем ако IP се получава през DHCP.Тогава трява всеки от екипа да има хранилище на Mercurial сървъра. Един вид публично хранилище,на което може да се слага код, когато някоя работа изисква повече от един човек.И това е! Може свободно да обменяме. А ако възникни пороблем, по който работят повече хора правим отделен клон и работим. Като свършим просто го прекратяваме.
Почти сме преключили, сега е време да изменим мисленето си и стила си на работа с дистрибутивните сорс системи. Ето тук има такъв.Happy hacking!Joel tutorialPractical ExampleOfficial Mercurial GuideMercurial Definitive guideMercurial Cheatsheet

C++ project rules

2010-12-10T13:05:00.008+02:00

C++ is a big and complex language that's why before starting new project it is very important to set up rules that whole team must follow.

Here is rules that my team follows:

#_______________________________________________________________________________
#
#   README
#_______________________________________________________________________________
#

 1. Prerequisites
 2. Building
 3. Installing
 4. Project structure
 5. Code convention
 6. Tools
 7. Contributing
 
#_______________________________________________________________________________
#                                                                 PREREQUISITES

 This project requires:
  * Cross-platform CMake v2.8.1+
  * GNU Make or equivalent.
  * GCC or an alternative, reasonably conferment C++ compiler.
  * Boost C++ Libraries v1.42+ [HEADERS and LIBRARIES]
  * Qt Framework v4.5+
  * glog v0.3+
  * gtest v1.4+

All include are located in $(PROJECT_ROOT)/extern as symbolic links to
installation directories so we can use them in unified way.

1. boost 
   http://www.boost.org/doc/libs/?view=categorized

2. googletest 
   http://code.google.com/p/googletest/

3. google-glog
   http://code.google.com/p/google-glog/

(optional)

4. gmock
   http://code.google.com/p/gmock/
   
5. soci
   http://soci.sourceforge.net/

#_______________________________________________________________________________
#                                                                      BUILDING

 This project uses the Cross-platform CMake build system. However, we
 have conveniently provided a wrapper configure script and Makefile so that
 the typical build invocation of "./configure" followed by "make" will work.
 For a list of all possible build targets, use the command "make help".

 NOTE: Users of CMake may believe that the top-level Makefile has been
 generated by CMake; it hasn't, so please do not delete that file.

#_______________________________________________________________________________
#                                                                    INSTALLING

 Once the project has been built (see "BUILDING"), execute "sudo make install".


#_______________________________________________________________________________
#                                                             PROJECT STRUCTURE

Given project template contains general solution. You can remove or add some directories.
For example you can add "gen" directory for all generated files or remove "lib" if some
package doesn't produce library code. 

To illustrate structure with example I added three directories (all with suffix .package).
You can remove them by searching project for .package or rename and reuse Make/CMake files.

Here is the basic source structure of the project:

        tools   - Directory for scripts and CMake modules
                
                  bin     - holds scripts for code building and checking
                  share   - resources that are needed by tools (like CMake modules)

        doc     - Output of doxygen and other documents related to project

                  Contains all Doxygen generated documents(removed by distclean) and project main page

        extern  - Directory holds external libraries that are common for all packages as symbolic links.

                  Keep there only libraries that are not in OS distribution or 
                  if you want to control versions. It's not allowed to be modified.

                  For example:
                          ln -s /opt/gtest-1.4.0 /opt/gtest

                  How to install external libs:
                  
                  1. Build them using prefix. For example boost:

                     TIP: It is convenient to use one prefix for libraries followed by lib name
                         ./bootstrap.sh --prefix=/opt/boost-1.42.0
                         ./bjam toolset=gcc install
                         ln -s /opt/boost-1.42.0 /opt/boost

                  2. Set the ROOT directory of a library in your environment so CMake/Makefile
                     can easily find/use them.
                  
                   For example:
                         export BOOST_ROOT=/opt/boost

                     TIP: If Boost is big for you take a look on very useful tool "bcp" or
                          build only required:

                          ./bootstrap.sh --with-<library_name>
                     
                     TIP: If CMake can't find some module try:

                          cmake --help-module <module_name> (e.g. FindBoost)

                  3. Put libraries location in LD_LIBRARY_PATH. Compiler search first here.

                         export LD_LIBRARY_PATH = .:path/to/lib/directory

                  4. Make symbolic link:
                      
                         cd extern
                         ln -s /opt/Qt Qt

                  5. If you have third party library that is used from many packages and it is possible/want
                     to modify create directory "src/thirdparty" and put it there
                  
        base      - Common macros, base classes and useful templates used through project

        "package" - Directory for a independent static/dynamic library or sub-project

                  bin         - Holds the output of compile process.
                  bin.debug   (ignored by svn)

                  doc         - Package specific documentation

                  include     - Package API. Include files that will be used from other packages.
                              (automatically transferred) 

                  lib         - Holds the output of build process if the result is
                                a library (shared library by default)

                  share       - Holds shared resources

                  sub-package - Code that is part of the enclosing package

                              TIP: Use nested namespaces for sub-package

                  thirdparty  - Holds the third party sources that could be modified for needs of library

                  .           - All code has to be located here
                            
                              TIP: Makefile or CMake will copy all public API (header files)
                                   in include directory. Doxygen skip it to avoid duplications.

                  test        - Holds simple tests for the package
                               (all test files are excluded form doxygen)
                             
                             TIP: You can divide tests as:
                                      unit
                                      integration
                                      end-to-end

                         data    - Data that will be used by test (optional)

Control template instantiations - No other file in the project should generate any specialized function
code even if the source code is available when the file is compiled (see g++ fno-implicit-templates parameter).
Every template specialization that is required is generated in one separate file and linked with the other
modules in the final link phase. Also remember that generation of the same function specialization
(by compiler or the user) more than once in compilation unit is an error.

GOOD PROGRAMMING PRACTICES:
      * During development you can use Makefile that is located in packages!
      * Locate all common template classes in base directory
      * Schemes for reducing template code size
        - cut member functions that do not depend on the type of the template argument
        - use counted pointers
      * Release to Release binary compatibility (RRBC) rules
        - the existing class hierarchy must remain unchanged
        - declarations for new virtual functions must appear after the declarations for
          all pre-existing virtual functions
        - all old virtual functions must remain and be declared in the same order
        - non-virtual functions and static member functions can be added without restriction
        - previously existing public or protected functions must continue to exist
        - the total size of an instance of a class must remain unchanged, and all public
          or protected data members must continue to exist and must remain at the same offset
          within the class. Private date that is referenced from public or protected inline
          members functions count as public data.
#_______________________________________________________________________________
#                                                               CODE CONVENTION

C++ code convention resources:
       http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml (use tools/bin/cppling.py)
with combination/or
       
"The Elements of C++ Style" book

1. Naming Your Files

   1.1 Each class definition should be in its own file where each file is named directly 
       after the class's name (like in Java).
   
       ClassName.h    // defines class ClassName
       ClassName.cpp

   1.2 Use separate files for each namespace-scope class, struct, union, enumeration, function, or
       overloaded function group

Give each file the same name as the element it contains, using the same case.
Consider also using separate files for template specializations.

   1.3 PkgConf/PkgDoc files in projects are for package configuration/documentation,
       AppConf/AppDoc for application as a whole.

2. Namespaces

   2.1 Every module, package in a project has own namespace.

Namespaces simply wrap all enclosed names with another name and they group logically related entities.
Namespace name should not correspond to a single entity but rather to a category to which names in the
namespace logically belong.

   2.2  Namespace names are all lower-case, and based on project names and possibly their directory structure.
       
Here is the name convention: project_subdir. In this way we mimic directory structure.

   2.3. It's usually sufficient to have one or two levels of namespace, with the odd extra level for internal
        details.

   2.4 Use unnamed namespaces instead of static to hide local functions and variables

3. Classes

   3.1 The object life cycle involves three activities: creation, destruction, and assignment!

   3.2 Always implement destructor, copy constructor and copy assignment operator (the rule of three)
       plus constructor and do not forget to call them from derived classes if use inheritance.
       Use DISALLOW_COPY_AND_ASSIGN macros to disallow copy and assignment.

   3.3 Be very careful especially when you have a pointers to dynamically allocated memory in your class
       * A constructor to either make an initial allocation or set the pointer to NULL.
       * A destructor to delete the dynamically allocated memory. Destructors are not inherited,
         and you cannot explicitly call a destructor of a base class, so define them virtual.
       * A copy constructor to make a copy of the dynamically allocated memory (deep copy).
       * An overloaded assignment operator to delete previous allocated and make a copy of the dynamically
         allocated memory (deep copy).

You can think of an assignment operator as a combination of a destructor and a copy constructor.
And do not forget to check for self assignment! An overloaded assignment operator defined in a derived
class doesn't automatically invoke the assignment operator for it's base class part so do not forget to call
assignment operator of the base class!

   3.4 Keep order:
class ClassName
{
  <friends classes>
  public:    // Behaviors (methods) that you want clients to use.
    // Method declarations
    // Member declarations
  protected: // Methods of a subclass can call a protected method
             // or access a protected member of an object
    // Method declarations
    // Member declarations
  private:   // Only if you want to restrict a access from subclasses
    // Method declarations
    // Member declarations
};
3.5 Naming convention        * The naming of the class always starts with a capital letter.        * If it is an interface(pure virtual) starts with "I".        * For all class members use underscore prefix '_' e.g  _speed all other are camelCase.        * Class methods are camelCase().        * Give Function Parameters the Same Name as the Member Variables You Assigned Them toclass Customer
{
  public:
    Customer(const string& name);
    void setName(const string& name);
  private:
    string _name;
};
* Constant types with 'k' e.g. kDefaultSpeed        * Static types with 's'.        * Free functions(not in a class) has to be in lower case using '_' and located in file that starts          with lower case. Good practice is to include file name in free functions name.          For example in file vmdsock.cpp to have methods:             vmdsock_init();             vmdsock_create();        * Pluralize the Names of Collections        * Use "other" for Parameter Names in Copy Constructors and Assignment Operators        * Use size_t where positive "int" numbers are required e.g. method parameters and loops    3.6 Consider the unit tests to be part of the actual implementation.Corresponding test class(test functionality) is in file which name starts with 'test' and it is locatedin test directory. It is good practice to group test and GTest framework allows that.Example of test grouping:     Fine-Grained Test:     testClassName.cpp  // contains tests for ClassName functionality, class API         Medium-Grained Tests:  testInsertBadData()     Large-Grained Tests:   testInsert()    3.7 To test classes for creation, assigning and all overloading operations create class with main method:        ClassNameTest.cpp   // easily you can run all static checkers on it!        or create something like that:#ifdef __TEST__
  int main(int argc, char *argv[]) {
  ...
#endif
Run a program transparently, but print a stack trace if it fails.gdb -batch -ex "run" -ex "bt" ${my_program} 2>&1 | grep -v ^"No stack."$
For automated unit tests we wanted our program to run normally, but if it crashed,        to add a stack trace to the output log. 3.8 If constructor takes only one parameter make it explicit. This will prevent confusing automatic        conversions         .......        explicit Car(const Driver& driver) {}           .......    3.9 Place each member variable in the initialization list in the same order as they fall        in the class declarationInitialization order is declared in the class itself, not in the constructor!That is because of caveat with initializer lists: they initialize data members in the order that theyappear in the class definition, not their order in the initializer list.    3.10 Think about using composition before using inheritance.    3.11 If you choose inheritance, keep following rules:      * Constructor must not call virtual functions.      * If class has even one virtual function implement virtual destructor      * Keep in mind that constructors, assignment operator and friends methods cannot be inherited      * Do not forget to call base constructor(initialize base), base copy constructor and base operator= first    3.12 Use mix-in (-able e.g. Callable) classes instead of multiple inheritance.    3.13 When you want class to be "abstract", define destructor as virtual.In this way prevent a class from being instantiated.    3.14 Think of private inheritance as "implemented using". See AddapterPattern (GoF)NOTE: The Liskov Substitution Principal states that it should always be possible to substitute      a base class for a derived class without any change in behavior. If you want to break this principal you      can use private inheritance.    3.15 Declare Enumerations within a Namespace or ClassTo avoid symbolic name conflicts between enumerators and other global names,nest enum declarations within the most closely related class or common namespace.If this is not possible, prefix each enumerator name with a unique identifier suchas the enumeration or module name.    3.16 Accept objects by reference and primitive or pointer types by value    3.17 Use a non-virtual function for behavior that is common to all classes         in the hierarchy and should not be overridden in derived classes.        3.18 Use a virtual function(and destructor) to define default behavior that may be         overridden in derived classes.    3.19 When picking data members for a class careful choose between: pointer(very flexible),         reference and value.If polymorphic behavior of data member is essential, use reference or a pointer as data member.GOOD PROGRAMMING PRACTICES:      * Use size_t variables for simple loop iteration and array subscripts      * When you write a subclass, you need to be aware of the interaction between parent classes and childclasses. Here is the construction order:        - The base class, if any, is constructedC++ will automatically call the default constructor for the parent class if one exists. But you can chain theconstructor just as when initializing data members in the initializer list        - Non-static data members are constructed in the order in which they were declared        - The body of the constructor is executed      * It is good style to repeat the virtual specification in a derived class      * Use default arguments to reduce the number of constructors      * Avoid using large arrays as automatic variables, use pointer to array      * Use QuickCheck++, Boost.Contract++4. Documenting and logging   4.1 Put all documentation of methods and classes in header files in source files document implementation       issues if necessary.   4.2 Use Java stile of documenting, doxygen will make documentation.GLOG is not just logging levels. It is much more, for example conditional logging, check macros, debug support.For more information see:     http://google-glog.googlecode.com/svn/trunk/doc/glog.html5. What to inline?   -small methods, such as accessors for private data   -functions returning state information about object   -small functions that are called repeatedlyGOOD PROGRAMMING PRACTICES:      * Place the method definition directly in the class definition and rarely use "inline" keyword.6. What to be in header files?      6.1 The header files should never contain definitions of functions or variables with the exceptions of       inline functions.   6.2 They should not contain definitions of unnamed namespaces.The header file may contain declarations of any names that have internal linkage, including const identifiers;types defined by typedef, class, struct, and enum; inline functions; named namespaces; and template declarationsand definitions.   6.3 A header file essentially should contain only interface information or specification of some implementation       file(s) of a library.In other words, everything included in a header file only serves as reference, and should not inflictany byte in the executable. But of course you can put some methods that will be inlined.7. Includes   7.1 Use following order:#include <corresponding .h file>
#include <C headers>
#include <STL headers>
#include <"external" libraries>  // third party code
#include <"internal" libraries>  // from other packages
    
<forward references>
7.2 Start include declaration from the root for the project:       #include "helper.package/include/subject_extract.h"   7.3 A file should never depend on an implementation file; in other words, you should       never write:            #include "something.cpp"   7.4 In implementation .cpp file do not write #includes that are already included in header files   7.5 Don't include a header file when a forward declaration is all you needGOOD PROGRAMMING PRACTICES:      * If you use a lot of forward declarations you might choose to prefer using boost::checked_delete.8. When to use friend methods?   -use them for testing private data stuffNOTES: 1. Also you can use simple hack:          g++ -Dprivate=public .....       2. GTEST has a special macro for mark test methods as friends - FRIEND_TEST   -for overloading operators to reflect syntax   -for methods that you don't want to become part of class interface   -provide better protection than other techniques when functions need to communicate    with more than one class.    For example:/**
* This provides a neat solution to the problem: 
* the multiply function has access to private data in
* both classes but we have not "opened them up" to anyone else.
*/
class Vector
{
  friend Vector operator* (const Matrix& lhs, const Vector& rhs);
  ....
}     
class Matrix
{
  friend Vector operator* (const Matrix& lhs, const Vector& rhs);
  ....
}
// free function
Vector operator* (const Matrix& lhs, const Vector& rhs) {
  ....
}
GOOD PROGRAMMING PRACTICES:      * Define friends methods in .cpp file(there is no need to repeated friend keyword)9. Be Const CorrectConst is a powerful tool for writing safer code, and it can help compiler optimizations.Your default choice for passing objects as parameters should be const reference.Only if you explicitly need to change the object should you omit the const.10. Hungarian notationThe right way to use it is to invent prefixes that provide useful information: the prefix indicatesthe "intent" rather than the "type". In particular, variables with the same C++ type but with differentroles often have different prefixes. For example:In a graphics application, variables representing coordinates have prefixes x, y, and, z.Then xCar, yCar, zCar (they all integers) is more meaningful.11. Implementation hiding    11.1 Use PIMPL(pointer to implementation) Idiom for public APIOvercome the language's separation anxiety: C++ makes private members inaccessible, but notinvisible. Where the benefits warrant it, consider making private members truly invisible using thePimpl idiom to implement compiler firewalls and increase information hiding.    11.2 Hide reference to a "secret" class. Use fallowing is the technique:FileOps.h - typical approach// "Cache" is the secret class
class FileOps
{
  public: 
    FileOps(const string, Cache&);
    ........
  private:
    string _fileName;
    ......
    Cache& _cache;
}
FileOps.h that hide secrets// "Cache" is the secret class
class FileOps
{
  public: 
    FileOps(const string inFileName);
    ........
  private:
    string _fileName;
    ......
    Cache* _cache; // not Cache&
}
FileOps.cpp............
FileOps::FileOps(const string inFileName) : _cache(new Cache()) {
.........
}
12. FormattingUse Allman brace style (also called exdented style) with modifications: use the curly brace on thesame line as the leading statement, except in the case of a function, class, or method name.GOOD PROGRAMMING PRACTICES:      * Separate logical blocks in files with some comment separator      * For emacs buffer aligning use 'google-c-style.el'      * YASnipped plug-in for Emacs could be used14. Ownership!When passing an object to a method, you have to think fairly carefully about whether you aretransferring ownership.When the ownership(= responsibility to destroy) of the object is passed to another function,it is usually better to use a smart pointer, such as std::auto_ptr.void manage(std::auto_ptr<T> t) {
...
}
...
// The reader of this code clearly sees ownership transfer.
std::auto_ptr<T> t(new T);
manage(t);
If a call to library returns memory pointers, who is responsible for freeing the memory:the caller or the library? If the library is responsible, when is the memory freed? Think about!References clarify ownership of memory! If you are writing a method and another programmer passes youa reference to an object, it is clear that you can read and modify(if not const) the object, but you haveno easy way of freeing its memory, so this is a sign that you are not responsible for destroying.GOOD PROGRAMMING PRACTICES:     * As much as possible, avoid returning a reference from a function because       - you can't indicate object creation failure       - created object could not be local. Who owns it?     * Use reference or pointer only if you want to return something polymorphic     * If you need reference counting smart pointer see SmartPointer or share_ptr<T>.     * If function do pointer arithmetic with parameter it is better to be defined as array       e.g. void X::f(T agrp[])     * If you want to forbid pointer arithmetic and delete just make it const       e.g. void X::f(T* const agrp)15. Prefer shared librariesIf you rapidly change the API then you need to recompile all of the programs that use the library inboth the shared and the static case. If you change the library but do not change the API then you mustrecompile all the programs that use the library only if they are linked statically.16. User object pool for large number of short-lived objectsIf you know that your program needs a large number of short-lived objects of the same type, you cancreate a pool, or cache, of those objects. See ObjectPool and Flyweight(GoF)           * You need to frequently create and destroy objects.       * They are similar in size.       * Allocating them on the heap is slow or could lead to memory fragmentation.       * Each object encapsulates a resource such as a database or network connection         that is slow to acquire and could be reused.17. ExceptionsWhen harmed, take exception: Prefer using exceptions over error codes to report errors. Use statuscodes (e.g., return codes, errno) for errors when exceptions cannot be used, and for conditions thatare not errors. Use other methods, such as graceful or ungraceful termination, when recovery isimpossible or not required.GOOD PROGRAMMING PRACTICES:       * Use RAII programming idiom       * If your code is with exceptions use auto_ptr for all local variables to make your code         exception save.       * Throw by value, catch by reference18. When to use parametrized types vs inheritance and delegation?       * use parametrized types when T doesn't affect its behavior and there is         no hierarchical structure between T objects       * use parametrized types if efficiency is essential(to avoid the overhead of virtual functions)       * use instances if the types of objects being operated on are not known at compile time19. Destructors, deallocation, and swap never fail! Period!Everything they attempt shall succeed: Never allow an error to be reported from a destructor, aresource deallocation function (e.g., operator delete), or a swap function. Specifically, typeswhose destructors may throw an exception are flatly forbidden from use with the C++ standardlibrary.20. STL    20.1 Use vector by default. Otherwise, choose an appropriate container    20.2 Store only values and smart pointers in containers    20.3 Prefer push_back to other ways of expanding a sequence    20.4 Check whether an operation invalidates iterators before using it    20.5 Ensure that template arguments satisfy the requirements of the corresponding         template parameter.    20.6 Don’t store auto-pointers in STL containers.    20.7 If you are traversing a container without changing its contents, use a const_iterator#_______________________________________________________________________________#                                                                         TOOLSUse valgrind, cppcheck and splint to check code    http://valgrind.org    http://cppcheck.wiki.sourceforge.net    http://www.splint.orgWrapper in other language around C++    http://www.swig.org/Better error messages information:    http://www.bdsoft.com/tools/stlfilt.html(optional)Better C++ GDB debug:    http://sourceware.org/gdb/wiki/ProjectArcherAlternative compiler:    http://clang.llvm.org/    http://dragonegg.llvm.org#_______________________________________________________________________________#                                                                  CONTRIBUTINGHere is typical project structure:http://code.google.com/p/various-code-fragments/source/browse/#svn/trunk/cpp/project.template#_______________________________________________________________________________#                                                                REQUIRED BOOKS

UNIX tools during C++ coding

2010-11-15T15:07:00.017+02:00

GCC
1. gcc/g++ useful tips and tricks:


See current C++ settings:
gcc -v -x c++ /dev/null -fsyntax-only
See all preprocessor defines:gcc -dM -E - < /dev/null
See what you have after pre-processing:     g++ -E -I.. -o _file_name_.ii _file_name_.cpp
See exactly where is defined something that you use it (e.g. for_each algorithm):grep --color=auto for_each -C10 _file_name_.ii
NOTE: set alias for colored grep because you will use it a lotSee what files the linker opens and in what order:g++ -Wl,-t _parameters_for_compilation_
See all includes, even those on the system path, so you can checkif it is taken from the right place:g++ -M _file_name_
2. Use "strace" (man strace) when program running to see what is opened.A system call, or syscall, is where a program crosses the boundary between user code and the kernel.Fortunately for us using strace, that boundary is where almost everything interesting happens in a typical program.
It logs all accesses to the OS, such as memory allocation, file I/O, system calls and launching sub-processesstrace -f -o strace.log ./_program_ _program_parameters_
You just want to see what files the program touches, or when it reads and writes data, or some other subset.strace -f -e trace=process,file,desc sh -c \
'for d in _some_directory_/*; do ls $d >/dev/null; done'
3. Use "ldd" (man ldd) to see what is needed and how is loadedldd ./_program_
4. Use command "nm" (man nm) that lists symbols contained in the object file or shared librarynm -D libhelp.package.so
This command lists symbol names from object files. These symbol names can be either functions, global variables, or static variables. For each symbol, the value, symbol type, and symbol name are displayed.Lower case symbol types mean the symbol is local, while upper case means the symbol is global or external.
In combination you can use c++filt(see additional tools) for demangling of symbols:nm libhelp.package.so | grep <searched symbol> | c++filt
NOTE: install c++filt from here5. For quick console code search skipping test directory ('ack' installed)find . -name \*.cpp | grep -v test/ | xargs ack -C 3 -w '_your_search_'
NOTE: I have this in my .ackrc:# Add CMake files
--type-set=cmake=.txt,.cmake
ack will automatically skips .svn .CVS etc.6. Use "pc" to see snapshot of current processesps -efwH
7. For complex declaration use "cdecl"For:typedef void(Number:: *Action)(int &);
Returns:"declare Action as pointer to member of class Number function (reference to int) returning void"Decoding Rule-set:
Rule 1:  Read from left to right looking for an identifier
Rule 2:  If the identifier is with parentheses, then evaluate inside the parentheses first
Rule 3:   look right for postfix operators ( ) or [ ]. If [] then it is an array, else if ()
          then it is a function.
Rule 4:   look left for prefix pointer asterisk '*'. If found the identifier is a pointer.

Rule 5a: If a const and/or volatile is next to a type specifier (int, long, etc.) it applies
         to that specifier
Rule 5b: if a const and/or volatile is not next to a type then it applies to the pointer asterisk on its
         immediate left
8. Problems with network, see mtrmtr is something like combination for traceroute and ping9. See disassembly output use following script#!/bin/sh
gcc -S -fverbose-asm -g -O0 test_program.c -o test_program.s
as -alhnd test_program.s > test_program.1st
GDB
The Fundamental Law of Debugging: avoid bugs when you’re coding, but plan forbugs in your code.
One factor that often distinguishes an experienced programmer from a novice is his or her debugging skills.1. Compile-Time Debug ModeYou can use preprocessor #ifdefs to selectively compile the debug code into your program.The advantage of this method is that your debug code is not compiled into the "release" binary,and so does not increase its size. The disadvantages are that there is no way to enable debugging at a customer site for testing or following the discovery of a bug, and your code starts to look cluttered and indecipherable.
In order to generate a debug version of the program, it should be compiled with the symbol DEBUG_MODEdefined. Your compiler should allow you to specify symbols to define during compilation.For example, g++ allows you to specify –Dsymbol on the compile command.2. Start-Time Debug ModeStart-time debug mode is an alternative to #ifdefs that is just as simple to implement. A command-lineargument to the program can specify whether it should run in debug mode. Unlike compile-time debugmode, this strategy includes the debug code in the "release" binary, and allows debug mode to be enabledat a customer site.However, it still requires users to restart the program in order to run it in debugmode, which is not always an attractive alternative for customers, and which may prevent you fromobtaining useful information about bugs.
bool isDebugSet(int argc, char** argv) {
for (int i = 0; i < argc; i++) {
    if (strcmp(argv[i], "-d") == 0) {
      return (true);
    }
  }
  return (false);
}
3. Run-Time Debug ModeThe most flexible way to provide a debug mode is to allow it to be enabled or disabled at run time. Oneway to provide this feature is to supply an asynchronous interface that controls debug mode on the fly. 4. Ring BuffersDebug mode is useful for debugging reproducible problems and for running tests. However, bugs oftenappear when the program is running in nondebug mode, and by the time you or the customer enablesdebug mode, it is too late to gain any information about the bug. One solution to this problem is to enabletracing in your program at all times. You usually need only the most recent traces to debug a program,so you should store only the most recent traces at any point in a program’s execution. One way to providethis limitation is through careful use of log file rotations.
5. GDB session exampler[un]                        Run to next breakpoint or to end
s[tep]                       Single-step, descending into functions
n[ext]                       Single-step without descending into functions
fin[ish]                     Finish current function, loop, etc. (useful!)
c[ontinue]                   Continue to next breakpoint or end
bt                           displays a stack frame for each active subroutine
up                           Go up one context level on stack (to caller)
                             Move to the function that called the present function
do[wn]                       Go down one level (only possible after up)
p[rint] <name>               Print value of variable called <name>
p/x <name>                   Print value of <name> in HEX format
p <name>@<n>                 Print <n> values starting at <name>
p <chars> (<tab>)            List all variables starting with <chars>
b[reak] <name>               Set a breakpoint at function <name>
b <class>::<name>            Set a breakpoint at <name> in <class>
b <class>::<tab>             List all members in <class>
b <file name>:line number    Set a breakpoint in <file name>
h[elp] b                     Documentation for setting breakpoints
i[nfo] b                     List breakpoints
i                            List all info commands
dis[able] 1                  Disable breakpoint 1
en[able] 1                   Enable breakpoint 1
d[elete] 1                   Delete breakpoint 1
d 1 2                        Delete breakpoints 1 and 2
d                            Delete all breakpoints
cond[ition] 1 <expr>         Stop at breakpoint 1 only if <expr> is true
cond 1                       Make breakpoint 1 unconditional
comm[ands] 1                 Add a list of gdb commands to execute each time breakpoint 1 is hit
(usually just print <var>)
e[xamine]                    Examine memory for a given memory address
Here is example debug session for class "Guitar" with methods "tick".After setting a breakpoint in the "tick" method of the class "Guitar" and continuingto the breakpoint, gdb prints something like:Breakpoint 2, Guitar::tick (this=0x805cde8) at Guitar.cpp:100
(gdb)
The "this" variable points to the current instance of the "Guitar" object. If an instance variable, say "pluckAmp", cannot be found when you try to print it, try instead(gdb) p this->pluckAmp
$1 = 0.296875
Also, "this" can be dereferenced to list all instance variables:(gdb) p *this
$2 = {<plucked3> = {<instrmnt> = {<stk> = {static STK_SINT8 = 1, 
static srate = 22050, _vptr.Stk = 0x8059020}, 
lastOutput = 0}, delayLine = 0x805ce70, delayLine2 = 0x8064f18, 
combDelay = 0x806cfb0, filter = 0x8075040, filter2 = 0x80750f8}
Suppose we're interested in filter2 above:(gdb) p filter2
$3 = (BiQuad *) 0x80750f8
Very cryptic! What does it mean? It says that "filter2" is an instance of the "BiQuad" class, so itcan be dereferenced.(gdb) p *filter2
$4 = {<filter> = {<stk> = {static STK_SINT8 = 1, 
static srate = 22050, _vptr.Stk = 0x80590e0}, 
gain = 0.60459499999999999, nB = 3, nA = 3, 
b = 0x8075140,  a = 0x8075120, 
outputs = 0x8075180, inputs = 0x8075160}, <no data fields>}
(gdb)
Note that the superclass instance variables are enclosed in curly brackets!(the leaf class instance variables begin with "gain" in this example).Suppose we want to see the "filter2" coefficients:(gdb) p filter2->b[0] @ 3
$5 = {1, -1.03, 0.21540000000000001}
(gdb) p filter2->a[0] @ 3
$6 = {1, -1.3337300000000001, 0.446191}
(gdb)
and so on.     How to set breakpoints in a template?objdump -t libMyLib.so | c++filt | grep 'BarAbstract.*Baz'
Result is:0000d2d6 w F .text 0000000a     MY_PLUGIN_A::Foo<MY_PLUGIN_A::BarAbstract>::Baz()
now(gdb) b MY_PLUGIN_A::Foo<MY_PLUGIN_A::BarAbstract>::Baz()
How to inspecting crashes?When program crash  we  want to know who called this method and we would like to be ableto examine values in the calling methods.So at the gdb prompt, we type backtrace which gives me the following output:(gdb) bt
#0  Node<int>::next (this=0x0) at main.cc:28
#1  0x2a16c in LinkedList<int>::remove (this=0x40160, 
item_to_remove=@0xffbef014) at main.cc:77
#2  0x1ad10 in main (argc=1, argv=0xffbef0a4) at main.cc:111
(gdb)
So in addition to what we knew about the current method and the local variables, we can now also see what methods called us and what their parameters were. For example, we can see that we were called byLinkedList<int>::remove () where the parameter item_to_remove is at address 0xffbef014.It may help us to understand our bug if we know the value of item_to_remove, so we want to see the valueat the address of item_to_remove. This can be done using the gdb x command using the address as a parameter.Here is what happens:(gdb) x 0xffbef014
0xffbef014: 0x00000001
(gdb)
So the program is crashing while trying to run LinkedList::remove with a parameter of 1.We have now narrowed the problem down to a specific function and a specific value for the parameter.You can use up command to browse backtrace:
(gdb) up 2
(gdb) list (to source code at this line)
gprof
Have a performance problems?Debugging will not help. Take a look at GNU gprof (Kprof for X addicted).Here is typical gprof session. Let's have a file NameDB.cpp and corresponding NameDBTest.cppthat contains main method:1. Compile itg++ -pg -g2 -O2 -lc -o namedb NameDB.cpp NameDBTest.cpp
2. Then you have to run it so the information will be collected. File "gmon.out" will be created by gprof../namedb
3. First look at the "flat profile" gprof namedb gmon.out -p
4. Then you can see call graphgprof namedb gmon.out -q
5. Finally, you might want to have an "annotated source" listing, which prints out the source code to the application,with notes on how many times each function is called.gprof namedb gmon.out -A
gprof's biggest limitation: it only profiles user time while the application is running.Typically, applications spend some of their time in user code and some in "system code," such as kernel system calls.You can see spent time:time ./namedb
Result is:real    0m15.350s
user    0m15.014s
sys     0m0.017s
"man time" for more information.To measure time spend on certain block of code you can use boost::progress_timer

Моето сто процентово, съвършено момиче

2008-02-27T13:17:00.010+02:00

от Харуки Мураками*

   В една красива априлска утрин, на не много широка улица в модерния квартал Харайку в Токио, се разминах със сто процентово, съвършено момиче.
Ако трябва да бъда честен, тя не изглеждаше добре. Не впечатляваше по никакъв начин. Не беше и облечена с нещо по-специално. Отзад косата и все още беше сплескана от възглавницата. Не беше и много млада - около тридесетте, затова може би неправилно да я наричам "момиче". Но въпреки това, сега гледайки я от тридесетина метра: Да, тя е сто процентово, съвършено момиче. В момента, в който се разминахме, устата ми стана суха като пустиня и нещо в гърдите ми се разбунтува.
   Може би имате свой тип момичета - такива с слаби глезени, или да кажем с големи очи, или изящни пръсти или си привлечен от жена, която цени храната. Аз също имам свои тип, разбира се. Понякога в ресторанта се улавям, че съм се втренчил в момичето на съседната маса, само защото има хубава форма на носа. Никои не може да твърди, че неговото сто процентово, съвършено момиче е от определен, конкретен тип. Така като ми правят впечатление носовете аз не мога да се сетя за гърдите и, дори и да са били големи. Всичко, за което се сещам е, че не беше голяма хубавица. Малко е странно.

"Вчера срещнах сто процентово, съвършено момиче" - ще кажа на някой.

"Така ли?" - ще ми отвърне той. "Красавица, а?"

"Не, не мисля."

"Тогава е била твой тип, нали?"

"Ами не знам. Не мога да си я спомня точно. Нито очите и, нито големината на гърдите."

"Много странно."

"Да. Странно наистина."

"Както и да е" ми отвръща отегчено, "Какво направи? Заговори ли я? Или тръгна след нея?"

"О, не. Просто се разминахме по улицата."

Тя вървеше от изток на запад, а аз от запад на изток. Беше наистина превъзходна априлска сутрин. Щеше ми се да бях я заговорил. Половин час щеше да е предостатъчно. Просто ще я помоля да ми разкаже за себе си, аз да и кажа нещо за мен, какво обичам да правя. Да се опитам да и обясня сложността на ориста и как тя ни довела на малката уличка в тази прекрасна априлска утрин на 1981. Със сигурност щеше да се получи нещо натъпкано с топли тайни, нещо като античен часовник, създаден във време на спокойствие и мир.
След като поговорихме, може би щяхме да обядваме някъде, после да изгледаме филм на Уди Алън и да пийнем по коктейл в фоайето на някой хотел. При добро стечение на обстоятелствата, щяхме да се любим. Може би сърцето ми щеше да откликне. Сега разстоянието между нас е 30 метра. Как да се доближа до нея? Какво да и кажа?

"Добро утро, госпожице. Ще може ли да ми отделите няколко минутки за разговор?"

Смешно е. Ще звуча като продавач на евтина стока.

"Извинете ме, бихте ли ми казали дали има в квартала денонощно химическо чистене?"

Не, глупаво е. Не нося никакви дрехи за химическо. Кой ще се хване на такава лъжа? А защо не, да кажа истината.

"Добро утро. Вие за мен сте сто процентово, съвършено момиче."

Не, тя няма да повярва. Или може би ще повярва, но няма да иска да говори с мен. Извинете, би казала тя, може да съм сто процентово, съвършено момиче за вас, но аз не мисля че вие сте сто процентово, съвършено момче за мен. Може и така да стане и тогава аз ще съм в неловка ситуация и ще ми се прииска да се разпадна на хиляди парчета. Едва ли ще мога да се съвзема от такъв шок. Аз съм на 32 и едно е сигурно, ще остарявам.

   Разминахме се пред един цветарски магазин. Топла струя въздух докосна кожата ми. Усещах аромата на рози премесен с влагата, изпаряваща се от топлия асфалт. Не мога да започна разговора. Тя носеше бял пуловер. В лявата и ръка видях, че държи писмо, на което му липсваше само пощенска марка. Вероятно е писала на някой дълго писмо. Може би е прекарала цялата нощ в писане, личеше по сънените и очи. Това писмо може би описваше нейната най-съкровена тайна. Направих още няколко крачки и пак се обърнах, тя се бе изгубила в тълпата. Сега вече късно, но знаех какво точно да и кажа. Това щеше да е дълъг разговор, прекалено дълъг, за да мога да го опиша в подробности. Идеята, която ме осени не беше от най-практичните.
Как да я опиша? Ами ще започна с "Имало едно време" и ще завърша с "Тъжна история, не мислиш ли?"

   Имало едно време, едно момче и едно момиче. Момчето било на 18, а момичето на 16. Той не изглеждал много добре, а и тя не била неземна красавица. Просто, самотно момче и обикновено момиче, като всички останали. Но те вярвали с цялото си сърце, че на този свят за тях съществуват сто процентово, съвършено момиче и сто процентово, съвършено момче. Да, те вярвали в това чудо. И един ден това чудо се случило. Този ден те се засекли на ъгъла на две малки улички.

"Това е странно", казал той.

"Аз те търсих през всичкото това време. Няма да повярваш, но ти си моето сто процентово, съвършено момиче."

"Ами да!" казала му тя, "ти си моето сто процентово, съвършено момче. Така съм си представяла всеки един детайл. Това е като сбъднат сън."

Те седнали на една пейка в парка, разказвали си своите истории и се държали за ръце. Те не били самотни вече. Постепенно открили, че си пасват на сто процента. Колко прекрасното нещо е да откриеш или да бъдеш открит от твоята половинка. Твоята сто процентова, съвършена половинка! Това е чудо, космическа сила. Така както си седели и говорели обаче, малко по-малко започнало да е прокрадва съмнение: Може ли една мечта да се случи толкова лесно? И така в една от техните паузи в разговора, момчето казало на момичето,

"Нека да направим един тест - само веднъж. Ако ние сме сто процента един за друг, тогава един ден, някъде ние ще се срещнем пак. И ако това стане, ние ще сме сигурни, че сме родени един за друг и веднага ще се оженим. Веднага. Какво мислиш?"

"Да," казала тя, "точно така би било добре да направим."

И така те се разделили, тя тръгнала на изток, той на запад. Теста, на който се подложили бил напълно излишен. Не е трябвало да го правят, защото те наистина били един за друг на 100%, и е истинско чудо, че са се срещнали. Младостта им изиграла лоша шега, нямало как да знаят. Студената и безразлична съдба си играела безмилостно с тях.
   Една зима и двамата легнали болни, поразени от ужасен грип. Седмици наред били между живота и смъртта. Накрая загубили всички свои спомени. Когато се събудили, не помнели нищо. Те станали двама лъчезарни млади хора, но макар да полагали непрестанно усилия не могли да си възвърнат предишните знания и чувства. Слава богу, те се превърнали в истински граждани, които знаят как да се прехвърлят от една спирка в метрото на друга, знаели и да как да изпращат специални колетни пратки. Дори очаквали отново любовта в проценти, 75% дори 85%.
Времето летяло с неочаквана лекота. Скоро той навършил 32, а тя 30. В една красива априлска утрин в търсене на ароматно кафе, за събуждане момчето вървяло от запад на изток, докато момичето вървяло от изток на запад, за да прати писмо. И това става на не много широка улица в модерния квартал Харайку в Токио. Те се разминали по средата на улицата. За много кратко светъл лъч просветнал в загубената им памет и поразил сърцата им. Всеки един от тях почувствал някакво странно усещане право в гърдите. Те знаели:

Тя е моето сто процентово, съвършено момиче.

Той е моето сто процентово, съвършено момче.

Но пламъчето на техните спомени бил толкова слаб и те не могли да имат решителността отпреди четиринадесет години.
Без да проронят и дума, те се разминават и изчезват в тълпата. Завинаги.

Тъжна история, не мислиш ли?

Да, вече знам, това трябваше да и кажа.

* преведено по мой вкус

Metallica в България!

2008-02-20T14:52:00.006+02:00

Бях на първия концерт в Пловдив, беше невероятно! Сега в София на 25 юли на Националния стадион "Васил Левски". Идва лято, а през лятото наистина стават чудеса. Леле Metallica, не мога да повярвам. Естествено започвам да разучавам всички песни, защото предния път мрънках под носа. Започвам с "Die Die My Darling"

Led Zeppelin като терапия

2008-02-05T00:58:00.004+02:00

   Колко бавно минава времето, когато нещо ти тежи. Нещо те яде отвътре и не си намираш място. Обвиняваш се и връщаш времето назад. Всички казват "нормално е", но никой не знае до кога. Няма универсално лекарство. Няма и универсален съвет. Аз с моите мисли и много много въпроси. От време на време, като остана сам нещо ме хваща за гърлото, подтискам се и угасвам. Самотата ми тежи. Не трябва да оставам сам, аз си знам.
   Сега обаче откривам истинското приятелство. Разбират ме, че страдам и се грижат за мен. Не ме оставят сам. Обичам приятелите си и аз ще помагам и аз ще бъда с тях. Бих се погубил ако ги нямах.
   Бавно оптимизмът ми се завръща. Винаги има и добра страна. Ще престана да си задавам въпроси, за да не си черня дните и мислите. Няма да се предам! Не съм сторил лошо. Един ден ще има Rock'n Roll, baby и аз ще бъда по-силен от всякога. Знам, че няма невъзможни неща.

"Невъзможно е само силна дума, използвана от слаби хора, намиращи за по-лесно да живеят в света, който им е отреден, вместо да открият силата в себе си да го променят. Невъзможно не е факт. То е убеждение. Невъзможно не е твърдение. То е предизвикателство. Невъзможно е осъществимо. Невъзможно е временно. Невъзможно е нищо."

Сънувах татко

2008-02-02T17:42:00.001+02:00

Сънувах татко! Мил и добър.

С много внимание ми обясняваше нещо, не помня какво точно. Обичаше да му помагам или да ми показва как се прави нещо. Да съм до него. Харесваше му близостта ни. Беше търпелив и усърден. Липсва ми страшно много! Искам да ме съветва, да се допитвам до него, да ми е опора.
Защо Господи ми го отне?

Татко винаги се грижеше за мен, и сега, когато се нуждая от него слезе да ми помогне. Беше със старите сини работнически дрехи усмихнат и вдъхващ кураж. С прошарена коса и меки топли длани, които усещах на рамото си.

"Как си, Злате?" - ми казва.
"Тъжно ми е татко!" - отвръщам.
"Ех сине, всичко ще се нареди, аз съм до теб!"

Исках да го докосна и да усетя мириса на машинно масло премесен с тютюнев дим пропит в дрехите му. Самото присъствие ме успокояваше и ми даваше сигурност. Близо до него, какво по-утешаващо от това. Татко, винаги съм те обичал, помагай и идвай в сънищата ми, нужен си ми.

Бях добро дете, не можех да го гледам на стълбите пред къщата тъжен с цигара в ръка заради някоя моя постъпка. Не можех да си позволя да го натъжа. Съвест и честност, това ни е крепяло. Не наранявам хората. Добър човек съм, помагам и сега. Какво съм сторил и с какво съм заслужил това, което ми причини жената до мен. Не съм жесток и никога няма да бъда. Татко ме учеше на това. Той наистина е преживял много и съдбата е била сурова с него. Не, не е се озлоби, просто пушеше много. Едни красив мъж, който тъеше много мъка в себе си. Мъка наслоена с времето. Как да го нараниш, затова бях добър син. Бих дал всичко от себе си да е до мен и да е щастлив.

Ще се радва да съм щастлив и аз, затова ми помага, затова идва в сънищата ми, затова и аз ще го обичам. Той е моя татко!

Идвай в сънищата ми, чакам те. Чу ли?

Start/Stop openvpn script

2008-01-18T15:03:00.008+02:00

Днес ми се наложи да направя VPN до Исландия с openvpn и дадения ми ключ (zlatozar.ovpn). Под линукс малко се озорих. То не бяха bridges то не беше чудо. Затова реших да сложа скрипта, който написах с много помощ от Google.
Първо си проверявам ip-то и routing таблицата:

$sudo ifconfig
$sudo route -n

След това стартирам скрипта (кръстил съм го open_vpn_script.sh):

#!/bin/bash

#################################
#
# Set up Ethernet bridge on Linux
# Requires: bridge-utils
#
#NOTE:
# iptables -A INPUT -i tap0 -j ACCEPT
# iptables -A INPUT -i br0 -j ACCEPT
# iptables -A FORWARD -i br0 -j ACCEPT
#
#################################

# Define Bridge Interface
br="br0"

# Define list of TAP interfaces to be bridged,
# for example tap="tap0 tap1 tap2".
tap="tap0"

# Define physical ethernet interface to be bridged
# with TAP interface(s) above.
eth="eth0"

eth_ip="your current ip"

eth_netmask="255.255.255.0"
eth_broadcast="xxx.xxx.xxx.255"

gw="your  getway"

case "$1" in

    start)
        for t in $tap; do
            openvpn --mktun --dev $t
        done

        brctl addbr $br
        brctl addif $br $eth

        for t in $tap; do
            brctl addif $br $t
        done

        ifconfig $eth 0.0.0.0 promisc up

        ifconfig $br $eth_ip netmask $eth_netmask broadcast $eth_broadcast
        route add default gw $gw
        ;;

    stop)
        ifconfig $br down
        brctl delbr $br

        for t in $tap; do
            openvpn --rmtun --dev $t
        done

        ifconfig $eth $eth_ip netmask $eth_netmask broadcast $eth_broadcast
        route add default gw $gw
        ;;

    *)
    echo "usage openvpn-bridge {start|stop}"

    exit 1
    ;;
esac

exit 0

И сега вече пускам смело:

# Start
sudo ./open_vpn_script.sh start
sudo openvpn zlatozar.ovpn

# Stop
sudo ./open_vpn_script.sh stop
sudo route -n

Сега ми изглежда лесно, но не мислех така сутринта.

Enum as dispatcher

2007-09-28T16:58:00.019+03:00

Вчера видях един от коментарите на предишно мое писание (ето това) и се сетих за нещо, което може да ми влезне в употреба. След като имам краен брой операции (enum), не може ли да "разхвърлям". Добре, няма да е много трудно. Примерно две операции: минус и плюс.

protected interface SumHandler {
   String handle(int one, int two);
}

protected enum Operation {

    minus(new MinusHandler()), plus(new PlusHandler());
    SumHandler handler;

    Operation(SumHandler handler) {
        this.handler = handler;
    }

    public String process(int one, int two) {
        return handler.handle(one, two);
    }
}

Това е случая, в който операциите плюс и минус са мнооого трудоемки или пък ни тряба отделна инстанция за всеки един от тях. При мен случая обаче е друг, много кратки обработки(даже тривиални), за които не е нужен никакво състояние.
Затова се изхитрям и ги реализирам като стойност, на която "присвоявам" функция. Да така е макар, че не се вижда на пръв поглед.

public class EnumAsDispatcher {
    private final static Logger log = Logger.getLogger(EnumAsDispatcher.class);

    protected interface SumHandler {
        String handle(int one, int two);
    }

    private static SumHandler minusHandler = new SumHandler() {

    public String handle(int one, int two) {
        log.debug("Substitution: one = " + one + ", two = " + two);
        return "Success substitution";
    }
};

private static SumHandler plusHandler = new SumHandler() {
    public String handle(int one, int two) {
        log.debug("Sum: one = " + one + ", two = " + two);
        return "Success sum";
    }
};

/** Enumeration for all operations (with attached functionality for each operation) */
protected enum Operation {
    minus(minusHandler), plus(plusHandler);

    SumHandler handler;

    Operation(SumHandler handler) {
        this.handler = handler;
    }

    public String process(int one, int two) {
        return handler.handle(one, two);
    }
}

    public static void main(String[] args) {

        String mathOperation = "minus";

        Operation operation = Operation.valueOf(mathOperation);
        operation.process(1, 2);

        mathOperation = "plus";

        operation = Operation.valueOf(mathOperation);
        operation.process(2, 1);
    }
}

Така че благодаря за подсказката

Repeated operations shortcut

2007-08-31T16:09:00.001+03:00

Когато пиша някакъв код се стремя той да е макасимално четим(разбирай опростен и подреден), но с времето нещата набъбват и четимоста отстъпва място на елегантноста. Ето и конкретния случай. Имам си класа SFAdapter, който прави връзката към SalesForce.com и изпънява заявките. Този менаджер може да бъде всъшност всякакъв примерно към базата. В него имах само три неща - инициализация на връзката, логин и метод за подаване на заявките:

................
public SFAdapter(final String sfUser, final String sfPass) {
if( sfUser==null || sfPass==null ) return;

this.sfUser=sfUser;
this.sfPass=sfPass;
try {
binding = (SoapBindingStub) new SforceServiceLocator().getSoap(new URL("some_url"));
} catch (Exception e) {

.....................

protected void doLogin() .............

public QueryResult query(final String ) .............

Да обаче проеката си нараства и се налага да се добавят все повече и повече методи, който са абсолуютно еднакви като структура:

public типа_които_ще_върне име(параметри) {
try {

изпънява_заявката

// следват нещата, които ще направи при грешка
} catch (UnexpectedErrorFault uef) {

И какво се получава - много писане. Верно проситчки неща ама много писане беее. Сегиз-тогиз е добре да се консултираш. Ето в какво се превърна кода след консултацията с колегите.
Повтарящите се неща да се на едно място. Операциите трябва да се уеднаквят. Това е посоката на мислене. И самия код:

public void delete(final String[] ids) {
executeInSf(new WriteCommand<Object>() {
public Object execute() throws UnexpectedErrorFault, RemoteException {
binding.delete(ids);
return null;
}
});
}

public SObject[] retrieve(final String fieldList, final String sObjectType, final String[] ids) {
return executeInSf(new ReadCommand<SObject[]>() {
public SObject[] execute() throws UnexpectedErrorFault, RemoteException {
return binding.retrieve(fieldList, sObjectType, ids);
}
});
}

private <T> T executeInSf(Command<T> c) throws RecoverableSFException, CriticalSFException {
try {
return c.execute();
} catch (UnexpectedErrorFault uef) {
if (uef.getExceptionCode().equals(ExceptionCode.INVALID_SESSION_ID)) {
try {
doLogin();
return c.execute();
} catch (UnexpectedErrorFault e) {
throw c.createException(e);
} catch (InvalidIdFault e) {
................... 
}

interface Command<T extends Object> {
T execute() throws UnexpectedErrorFault, RemoteException;
RecoverableSFException createException(Exception cause);
}

abstract class ReadCommand<T extends Object> implements Command<T>{
public SFReadException createException(Exception cause) {
return new SFReadException(cause);
}
}

abstract class WriteCommand<T extends Object> implements Command<T>{
public SFWriteException createException(Exception cause) {
return new SFWriteException(cause);
}
}

С простички думи. Операцията, която трябва да се изпълни я дефинираме в интерфейс(Command), а нещата които се повтарят в един метод, който приема като параметър този инерфейс(executeInSf). Следва и самото изпълнение(retrieve), която не прави нищо друго освен да иплементира изпълнението на операцията - execute метода.
NOTE: В метода delete забележете, че нама return, а execute трябва задължително да върне стойност и тя е null.
Малко се усложниха нещата, защото имам два вида грешки:

try {
doLogin();
return c.execute();
} catch (UnexpectedErrorFault e) {
// see here!
throw c.createException(e);
...........

Правилото е, ако има има различия и допълнителни неща те се отделят в абстрактни класове, които наследяват инерфейса.

И всичко това само, защото в Java не можем да предаваме функции. Ако беше така, на executeInSf щахме да предадем функцията, която трябва да се изпълни. Може би посоката на мислене трябва да е към езици за функционално програмиране.

Daily thoughts - 4

2007-08-02T15:31:00.000+03:00

Enum as dispatcher
Днес доработвах един код и ми хрумна идея. Какво ще стане ако се наложи да се направят две различни операции по даден критерий? В моя случай критерия е дали обекта е получен от XML или HTML файл. В зависимост се тръгва по две отделни "пътеки" да ги наречем (някъде навътре в бизнес логиката). Естественно първото нещо, което хрумва е да се приложи Factory pattern. Идеята не е никак лоша ако "пътеките" са дълги, резултатните обекти са много различни и се очаква критериите да набъбват. Тогава много лесно може да се добави трети обект в йерархията. Картинката е:


                     +-------------+
                     |             |
                     | BaseObject  |
                     +-------------+
                        ^  ^   ^
                    +---|  |   |------+
                    |      |          |
                    |      |          |
              XMLObject HTMLObject NextObject

Имайки тази йерархия следва и да имам дипечер, който да казва какво да се истанцира. Нещо такова:


public class ObjectFactory {
    .........
    public static ObjectReader getObjectReader( InputStream is ) {
        int objectType = figureOutObjectType( is );

        switch( objectType ) {
        case ObjectReaderFactory.XML:
            return new XMLReader( is );
        case ObjectReaderFactory.HTML:
            return new HTMLReader( is );
        ..........
        // etc.
        }
    }
}

Да ама при мен ситуацията се различава - двата обекта са почти идентични. Те се различават само по едно единственно действие - операцията diff. Ако е XML се пуска някъде в "пътеката" xmldiff.py ако не, htmldiff.py. Ще имам само на едно място if. Не мога ли да сложа действието в типа. Така измествам фокуса. Естественно щом имам изброим брой действия най-добре да си ползвам enum. Хехе там лесно мога да дефинирам и операцията в зависимост от типа:


public enum DiffType {

    XML {

        String diffProgram()
        {
            return FileConstants.PYTHON_XMLDIFF_PROGRAM;
        }
    },

    HTML {

        String diffProgram()
        {
            return FileConstants.PYTHON_HTMLDIFF_PROGRAM;
        }
    };

    // declare the methods defined by this enum
    public abstract String diffProgram();
}

Ееее от тук нататък е лесно.



private void diffFilePrepare(final MobileOperator operator) throws IOException
{
    .........
    // dispach by type
    diffMaker.madeDiffDisplay(operator.getDiffType());
    .........
}


public void madeDiffDisplay(DiffType type) throws IOException
    {
        .........
        try {
            pythonLine[0] = "python";
            pythonLine[1] = type.diffProgram();

        .........
        } catch (InterruptedException e) {
            log.error("External program was interupted.");
        }

    }

Така хем си знам типа, хем и операцията за този тип. По-четимо го намирам. Е, разбира се то това е частен случай. Иначе Factory pattern rulez!

Daily thoughts - 3

2007-07-23T17:34:00.000+03:00

Тази събота и неделя си поиграх да си направя firewall ето и резултата:


#!/bin/bash

#INSTALL(Debian rulez)
#      1. write this file as /etc/init.d/firewall
#      2. chmod 755 /etc/init.d/firewall
#      3. update-rc.d firewall defaults
#
#REMOVE
#    update-rc.d -f firewall remove
#
# Author: zlatozar@gmail.com
# Date: 2007/03/04



#Our complete stateful firewall script.  This firewall can be customized for 
#a laptop, workstation, router or even a server. :)

#change this to the name of the interface that provides your "uplink"
#(connection to the Internet)

UPLINK="eth0"

#if you're a router (and thus should forward IP packets between interfaces),
#you want ROUTER="yes"; otherwise, ROUTER="no"

ROUTER="yes"

#change this next line to the static IP of your uplink interface for static SNAT, or
#"dynamic" if you have a dynamic IP.  If you don't need any NAT, set NAT to "" to
#disable it.

NAT="dynamic"

#change this next line so it lists all your network interfaces, including lo

INTERFACES="lo eth0 eth1"

#change this line so that it lists the assigned numbers or symbolic names (from
#/etc/services) of all the services that you'd like to provide to the general
#public.  If you don't want any services enabled, set it to ""

SERVICES="http https ftp smtp ssh rsync"
# SRVICES_SAMBA="netbios-ssn microsoft-ds"

start() {

    echo "Starting firewall..."
    iptables -P INPUT DROP
    iptables -A INPUT -i ! ${UPLINK} -j ACCEPT
    iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
    
    #enable public access to certain services
    for x in ${SERVICES}
      do
      iptables -A INPUT -p tcp --dport ${x} -m state --state NEW -j ACCEPT
    done
 
    # SAMBA ---------
    iptables -A INPUT -p tcp --dport 137:139 -j ACCEPT
    iptables -A INPUT -p tcp --dport 445 -j ACCEPT

    iptables -A INPUT -p udp --dport 137:139 -j ACCEPT
    iptables -A INPUT -p udp --dport 1025:65535 -j ACCEPT
    # --------- 

    iptables -A INPUT -p tcp -i ${UPLINK} -j REJECT --reject-with tcp-reset
    iptables -A INPUT -p udp -i ${UPLINK} -j REJECT --reject-with icmp-port-unreachable
 

    #explicitly disable ECN
    if [ -e /proc/sys/net/ipv4/tcp_ecn ]
 then
 echo 0 > /proc/sys/net/ipv4/tcp_ecn
    fi   

    #disable spoofing on all interfaces
    for x in ${INTERFACES} 
      do 
      echo 1 > /proc/sys/net/ipv4/conf/${x}/rp_filter     
    done

    if [ "$ROUTER" = "yes" ]
 then
 #we're a router of some kind, enable IP forwarding
 echo 1 > /proc/sys/net/ipv4/ip_forward
 if [ "$NAT" = "dynamic" ]
     then
     #dynamic IP address, use masquerading 
     echo "Enabling masquerading (dynamic ip)..."
     iptables -t nat -A POSTROUTING -o ${UPLINK} -j MASQUERADE
 elif [ "$NAT" != "" ]
     then
     #static IP, use SNAT
     echo "Enabling SNAT (static ip)..."
     iptables -t nat -A POSTROUTING -o ${UPLINK} -j SNAT --to ${UPIP}
 fi
    fi
}

stop() {
    echo "Stopping firewall..."
    iptables -F INPUT
    iptables -P INPUT ACCEPT
    
    #turn off NAT/masquerading, if any
    iptables -t nat -F POSTROUTING
}

# Menu

case "$1" in
    start)
        start
        ;;
    stop)
        stop
        ;;
    *)
        echo "Usage: /etc/init.d/firewall {start|stop}"
        exit 1
esac

exit 0

PS. Това е firewall за моята работна станция затова се наложи да добавя специялна секция за SAMBA. Ако ще го ползвате за сервър я махнете.

Start study JavaScript

2007-06-29T15:24:00.012+03:00

Ща не ща, налага се да уча JavaScript. Както винаги почнах да го разглеждам отдалече. Като за начало ми трябваше нещо като въведение. Потъсих в google и се спрях на ре-интро. Не е кой знае какво, но важните концепции са там. Разбира се това съвсем не е достатъчно се огледах за следващата порция. Намерих я в вид на видео лекции. Те са на Douglas Crockford, който се води JS гурото на Yahoo. Много добри практики показва този човек. Не ги разбрах всичките и затова ще трябва пак да ги прегледам. Ето и линковете:

Beginers
http://video.yahoo.com/video/play?vid=111593&fr=
http://video.yahoo.com/video/play?vid=111594&fr=
http://video.yahoo.com/video/play?vid=111595&fr=
http://video.yahoo.com/video/play?vid=111596&fr=

Advanced
http://video.yahoo.com/video/play?vid=111585&fr=
http://video.yahoo.com/video/play?vid=111586&fr=
http://video.yahoo.com/video/play?vid=111587&fr=
and
http://video.yahoo.com/watch/630959/2974197

Super Advanced
http://ejohn.org/apps/learn/

http://jibbering.com/faq/faq_notes/closures.html

DOM
http://video.yahoo.com/video/play?vid=111582&fr=
http://video.yahoo.com/video/play?vid=111583&fr=
http://video.yahoo.com/video/play?vid=111584&fr=

Others

http://yuiblog.com/crockford/

So far so good. Имам някакви базови знаня ама как да започна да пиша и да бриша. Тъй като много от нещата си пиша в Eclipse и Emacs трябваше да ги настроя. За Eclipse свалих JSEclipse, a тук е update сайта. При Emacs има избор, най-доброто мисля е това. В него има инструкция как да се инсталира. Редакторите ги докарах, ама как ще тествам нещата. Оказа се, че има JavaScript Shell. Много добре работи. Ето как го настроих.

cvs -d :pserver:anonymous@cvs-mirror.mozilla.org:/cvsroot login
cvs -d :pserver:anonymous@cvs-mirror.mozilla.org:/cvsroot co -l mozilla/js/src mozilla/js/src/config mozilla/js/src/editline mozilla/js/src/fdlibm

cd mozilla/js/src
make -f Makefile.ref

И сега нещата са много лесни. Правя си update преди да почна:

cd mozilla
cvs up

cd mozilla/js/src
make -f Makefile.ref

Направих си и alias в .bashrc. Така че и откъдето и да напиша js си отварям js-shell.

alias js='/home/zlatozar/js-shell/mozilla/js/src/Linux_All_DBG.OBJ/js -i'

Удобно е да провериш нещо набъзо. Особенно за примерите от книгата или ако има някаква по заплетена ситуация. Май имам всичко необходимо. Сега само четене и практика. И разбира се много debug с чудесния Firefox plug-in FireBug. Поставянето на breakpoint става като се напише debugger в кода. Нищо работа.

Друг вариант е да се ползва Rhino.
Като чета нещо в случая книгата "JavaScript Definitive Guide" си подчертавам най-важните, така че лесно да мога да се върна към тях и да ги запомня. Ето и линк към примерите от книгата http://www.davidflanagan.com/javascript5/

И най-важното е да се разбере, че JavaScript e:
A language which has Scheme like semantics and Java like syntax

Core JavaScript Language Notes:

Intro
When a JavaScript interpreter is embedded in a web browser, the result is client-side JavaScript.
Mozilla provides two different versions of the JavaScript 1.5 interpreter. One is written in C and is called SpiderMonkey. The other is written in Java and, in a flattering reference to this book, is called Rhino. Useful tool that is not strictly a debugger is jslint, which looks for common problems in JavaScript code (see jslint). JavaScript programs are written using the Unicode character set. It is a case-sensitive language. Note, however, that HTML is not case-sensitive (although XHTML is).

Lexical Structure
You may omit the semicolon if each of your statements is placed on a separate line. JavaScript allows you to work with three primitive datatypes: numbers, strings of text (known as strings), and Boolean truth values (known as booleans). It also defines two trivial datatypes, null and undefined, each of which defines only a single value. In addition to these primitive datatypes, JavaScript supports a composite datatype known as an object. An object (that is, a member of the datatype object) represents a collection of values (either primitive values, such as numbers and strings, or composite values, such as other objects). Objects in JavaScript have a dual nature: an object can represent an unordered collection of named values or an ordered collection of numbered values. JavaScript defines another special kind of object, known as a function. A function is an object that has executable code associated with it. A function may be invoked to perform some kind of operation.

Numbers
JavaScript differs from programming languages such as C and Java in that it does not make a distinction between integer values and floating-point values. All numbers in JavaScript are represented as floating-point values.

Strings
A string is a sequence of Unicode letters, digits, punctuation characters, and so on; it is the JavaScript datatype for representing text. A string comprises a sequence of zero or more Unicode characters enclosed within single or double quotes (' or "). Double-quote characters may be contained within strings delimited by single-quote characters, and single-quote characters may be contained within strings delimited by double quotes. One of the built-in features of JavaScript is the ability to concatenate strings. If you use the + operator with numbers, it adds them. But if you use this operator on strings, it joins them by appending the second to the first. Numbers are automatically converted to strings when needed. If a number is used in a string concatenation expression. To make number-to-string conversions more explicit, use the String( ) function:

var string_value = String(number);

Another technique for converting numbers to strings uses the toString( ) method:

string_value = number.toString( );

When a string is used in a numeric context, it is automatically converted to a number. This means, for example, that the following code actually works:

var product = "21" * "2"; // product is the number 42

To allow more flexible conversions, you can use parseInt( ) and parseFloat( ). These functions convert and return any number at the beginning of a string, ignoring any trailing nonnumbers. parseInt( ) parses only integers, while parseFloat( ) parses both integers and floating-point numbers. If a string begins with 0x or 0X, parseInt( ) interprets it as a hexadecimal number.
Strings are intentionally immutable. Strings are compared by value.

Booleans
Boolean values are represented by the literals true and false. Boolean values are easily convertible to and from other types and are often automatically converted. If a boolean value is used in a numeric context, true converts to the number 1 and false converts to the number 0. If a boolean value is used in a string context, true converts to the string "true" and false converts to the string "false". If a number is used where a boolean value is expected, the number is converted to True unless the number is 0 or NaN, which are converted to false. If a string is used where a boolean value is expected, it is converted to true except for the empty string, which is converted to false. null and the undefined value convert to false, and any non-null object, array, or function converts to true.

Objects
An object is a collection of named values. These named values are usually referred to as properties of the object. (Sometimes they are called fields of the object, but this usage can be confusing.) To refer to a property of an object, you refer to the object, followed by a period and the name of the property. When a function value is stored in a property of an object, that function is often called a method, and the property name becomes the method name. To invoke a method of an object, use the . syntax to extract the function value from the object and then use the ( ) syntax to invoke that function. For example, to invoke the write( ) method of an object named document, you can use code like this:

document.write("this is a test");

Objects in JavaScript can serve as associative arrays; that is, they can associate arbitrary data values with arbitrary strings. When an object is used in this way, a different syntax is generally required to access the object's properties: a string containing the name of the desired property is enclosed within square brackets. Using this syntax, you can access the properties of the image object mentioned previously with code like this:

image["width"] 
image["height"]

An object literal (also called an object initializer) consists of a comma-separated list of colon-separated property/value pairs, all enclosed within curly braces. Thus, the object point in the previous code can also be created and initialized with this line:

var point = { x:2.3, y:-1.2 };

When a non-null object is used in a Boolean context, it converts to true. When an object is used in a string context, JavaScript calls the toString( ) method of the object and uses the string value returned by that method. When an object is used in a numeric context, JavaScript first calls the valueOf( ) method of the object.

Douglas Crockford: "JavaScript is fundamentally about objects. Arrays are objects. Functions are objects. Objects are objects. So what are objects? Objects are collections of name-value pairs. The names are strings, and the values are strings, numbers, booleans, and objects (including arrays and functions). Objects are usually implemented as hashtables so values can be retrieved quickly.

If a value is a function, we can consider it a method. When a method of an object is invoked, the this variable is set to the object. The method can then access the instance variables through the this variable.

Objects can be produced by constructors, which are functions which initialize objects. Constructors provide the features that classes provide in other languages, including static variables and methods."
Arrays
An array is a collection of data values, just as an object is. While each data value contained in an object has a name, each data value in an array has a number, or index. In JavaScript, you retrieve a value from an array by enclosing an index in square brackets after the array name. Arrays may contain any type of JavaScript data, including references to other arrays or to objects or functions. For example:

document.images[1].width

Associative arrays are indexed by strings. Also note that JavaScript does not support multidimensional arrays, except as arrays of arrays. Finally, because JavaScript is an untyped language, the elements of an array do not all need to be of the same type, as they do in typed languages like Java. Creating:

var a = new Array( );
a[3] = { x:1, y:3 }; 

var a = new Array(10); 
var b = [1.2, "JavaScript", true, { x:1, y:3 }];

Undefined elements can be included in an array literal by simply omitting a value between commas. For example, the following array contains five elements, including three undefined elements:

var sparseArray = [1,,,,5];

You can access elements of an array using square brackets ([]), and you can access elements of an object using a dot (.). Both [] and . are treated as operators in JavaScript.
The . operator expects an object as its left-side operand and an identifier (a property name) as its right-side operand. The right-side operand should not be a string or a variable that contains a string; it should be the literal name of the property or method, without quotes of any kind. Here are some examples:

document.lastModified 
navigator.appName 
frames[0].length 
document.write("hello world")

If the specified property does not exist in the object, JavaScript does not issue an error but instead simply returns undefined as the value of the expression.

null and undefined
The JavaScript keyword null is a special value that indicates no value. null is usually considered a special value of object typea value that represents no object. null is a unique value, distinct from all other values. When a variable holds the value null, you know that it does not contain a valid object, array, number, string, or boolean value. When null is used in a Boolean context, it converts to false. When used in a numeric context, it converts to 0. And when used in a string context, it converts to "null".
undefined is returned when you use either a variable that has been declared but never had a value assigned to it or an object property that does not exist. Note that this special undefined value is not the same as null.

Wrapper Objects
JavaScript besides supporting the number, string, and boolean datatypes, JavaScript also supports Number, String, and Boolean classes. These classes are wrappers around the primitive datatypes. A wrapper contains the same primitive data value, but it also defines properties and methods that can be used to manipulate that data. Note that any number, string, or boolean value can be converted to its corresponding wrapper object with the Object( ) function:

var number_wrapper = Object(3);

By Reference, by Value
The basic rule in JavaScript is this: primitive types are manipulated by value, and reference types, as the name suggests, are manipulated by reference. Numbers and booleans are primitive types in JavaScript primitive because they consist of nothing more than a small, fixed number of bytes that are easily manipulated at the low levels of the JavaScript interpreter. Objects, on the other hand, are reference types. Arrays and functions, which are specialized types of objects, are therefore also reference types. These datatypes can contain arbitrary numbers of properties or elements, so they cannot be manipulated as easily as fixed-size primitive values can.

Varables
An important difference between JavaScript and languages such as Java and C is that JavaScript is untyped. This means, in part, that a JavaScript variable can hold a value of any datatype, unlike a Java or C variable, which can hold only the one particular type of data for which it is declared. A feature related to JavaScript's lack of typing is that the language conveniently and automatically converts values from one type to another, as necessary. Variables declared with var are permanent: attempting to delete them with the delete operator causes an error.

If you attempt to read the value of an undeclared variable, JavaScript generates an error. If you assign a value to a variable that you have not declared with var, JavaScript implicitly declares that variable for you. Note, however, that implicitly declared variables are always created as global variables, even if they are used within the body of a function.
To prevent the creation of a global variable (or the use of an existing global variable) when you meant to create a local variable to use within a single function, you must always use the var statement within function bodies. It's best to use var for all variables, whether global or local.

Within the body of a function, a local variable takes precedence over a global variable with the same name. If you declare a local variable or function parameter with the same name as a global variable, you effectively hide the global variable. JavaScript does not have block-level scope. All variables declared in a function, no matter where they are declared, are defined throughout the function. In the following code, the variables i, j, and k all have the same scope: all three are defined throughout the body of the function.

function test(o) {     
   var i = 0;                        // i is defined throughout function 
   if (typeof o == "object") { 
      var j = 0;                     // j is defined everywhere, not just block 
      for(var k=0; k < 10; k++) {  // k is defined everywhere, not just loop 
         document.write(k); 
      } 
      document.write(k);            // k is still defined: prints 10 
   } 
   document.write(j);               // j is defined, but may not be initialized 
}

Local variable is defined throughout, it is not actually initialized until the var statement is executed.
REMEMBER:

function f( ) {     
   var scope;        // Local variable is declared at the start of the function 
   alert(scope);     // It exists here, but still has "undefined" value 
   scope = "local";  // Now we initialize it and give it a value 
   alert(scope);     // And here it has a value 
}

It is good programming practice to place all your variable declarations together at the start of any function.

Undeclared variables are undefined because they simply do not exist. As described earlier, assigning a value to an undeclared variable does not cause an error; instead, it implicitly declares the variable in the global scope. The second kind of undefined variable is one that has been declared but has never had a value assigned to it. If you read the value of one of these variables, you obtain its default value, undefined. Variables in JavaScript are fundamentally the same as object properties.

When the JavaScript interpreter starts up, one of the first things it does, before executing any JavaScript code, is create a global object. The properties of this object are the global variables of JavaScript programs. When you declare a global JavaScript variable, what you are actually doing is defining a property of the global object. In top-level code (i.e., JavaScript code that is not part of a function), you can use the JavaScript keyword this to refer to the global object. Within functions, this has a different use.

Each time the JavaScript interpreter begins to execute a function, it creates a new execution context for that function. An execution context is, obviously, the context in which any piece of JavaScript code executes. An important part of the context is the object in which variables are defined. Thus, JavaScript code that is not part of any function runs in an execution context that uses the global object for variable definitions. And every JavaScript function runs in its own unique execution context with its own call object in which local variables are defined. Client-side JavaScript code in each frame or window runs in its own execution context and has its own global object.

Every JavaScript execution context has a scope chain associated with it. This scope chain is a list or chain of objects. When JavaScript code needs to look up the value of a variable x (a process called variable name resolution), it starts by looking at the first object in the chain. If that object has a property named x, the value of that property is used. If the first object does not have a property named x, JavaScript continues the search with the next object in the chain. If the second object does not have a property named x, the search moves on to the next object, and so on.

Expressions and Operators
When constructing JavaScript expressions, you must pay attention to the datatypes that are being passed to operators and to the datatypes that are returned. Different operators expect their operands' expressions to evaluate to values of a certain datatype. For example, it is not possible to multiply strings, so the expression "a" * "b" is not legal in JavaScript. Note, however, that JavaScript tries to convert expressions to the appropriate type whenever possible, so the expression "3" * "5" is legal. Its value is the number 15, not the string "15". The == and === operators check whether two values are the same, using two different definitions of sameness. Both operators accept operands of any type, and both return true if their operands are the same and false if they are different. The === operator is known as the identity operator, and it checks whether its two operands are "identical" using a strict definition of sameness. The == operator is known as the equality operator; it checks whether its two operands are "equal" using a more relaxed definition of sameness that allows type conversions.

// If max_width is defined, use that.  Otherwise look for a value in 
// the preferences object.  If that is not defined use a hard-coded constant. 
var max = max_width || preferences.max_width || 500;

Statements

with(object)
  statement

This statement effectively adds object to the front of the scope chain, executes statement, and then restores the scope chain to its original state.

// Access form elements directly here. For example: 
with(frames[1].document.forms[0]) {     
   name.value = ""; 
   address.value = ""; 
   email.value = ""; 
}

Objects and Arrays
An important point to notice about object properties is that you can create a new property of an object simply by assigning a value to it. Although you declare variables with the var keyword, there is no need (and no way) to do so with object properties. Furthermore, once you have created an object property by assigning a value to it, you can change the value of the property at any time simply by assigning a new value:

book.title = "JavaScript: The Rhino Book"

Objects are often called an associative array - a data structure that allows you to dynamically associate arbitrary values with arbitrary strings. The term map is often used to describe this situation as well: JavaScript objects map strings (property names) to values. In JavaScript, every object has a constructor property that refers to the constructor function that initializes the object. The instanceof operator checks the value of the constructor property, so the code above could also be written:

if ((typeof o == "object") && (o instanceof Date))  // Then do something with the Date object...

Function
Functions may have parameters, or arguments local variables whose value is specified when the function is invoked. Functions often use these arguments to compute a return value that becomes the value of the function-invocation expression. When a function is invoked on an object, the function is called a method, and the object on which it is invoked is passed as an implicit argument of the function. If the "return" statement does not have an associated expression, it returns the "undefined" value.
If you pass more arguments than the function expects, the function ignores the extra argumetnts. If you pass fewer than expected, the parameters you omit are given the undefined value.

Example of nested function:

function hypotenuse(a, b) { 
   function square(x) { return x*x; } 
   return Math.sqrt(square(a) + square(b)); 
}

Nested functions may be defined only at the top level of the function within which they are nested. That is, they may not be defined within statement blocks, such as the body of an if statement or while loop. Note that this restriction applies only to functions defined with the function statement. Function literal expressions, may appear anywhere. Example of function literal:

var f = function fact(x) { if (x <= 1) return 1; else return x*fact(x-1); };

Because function literals are created by JavaScript expressions rather than statements, they are quite flexible and are particularly well suited for functions that are used only once and need not be named. For example, the function specified by a function literal expression can be stored into a variable, passed to another function, or even invoked directly:

f[0] = function(x) { return x*x; };                // Define a function and store it
a.sort(function(a,b){return a-b;});                // Define a function; pass it to another
var tensquared = (function(x) {return x*x;})(10);  // Define and invoke

Function names are often verbs or phrases that begin with verbs. It is a common convention to begin function names with a lowercase letter. When a name includes multiple words, one convention is to separate words with underscores like_this(); another convention is to begin all words after the first with an uppercase letter likeThis(). Functions that are supposed to be internal or hidden are sometimes given names that begin with an underscore.

Optional Arguments
When a function is invoked with fewer arguments than are declared, the additional arguments have the undefined value! It is often useful to write functions so that some arguments are optional and may be omitted when the function is invoked. Note that when designing functions with optional arguments, you should be sure to put the optional ones at the end of the argument list so that they can be omitted. The programmer who calls your function cannot omit the first argument and pass the second, for example. In this case, he would have to explicitly pass undefined or null as the first argument. Functions like this one that can accept any number of arguments are called variadic functions, variable arity functions, or varargs functions. Within the body of a function, the identifier arguments has special meaning. arguments is a special property that refers to an object known as the Arguments object. The Arguments object is an array-like object that allows the argument values passed to the function to be retrieved by number, rather than by name. In addition to its array elements, the Arguments object defines a callee property that refers to the function that is currently being executed. This property is rarely useful, but it can be used to allow unnamed functions to invoke themselves recursively. For instance, here is an unnamed function literal that computes factorials:

function(x) { 
   if (x <= 1) return 1; 
   return x * arguments.callee(x-1); 
}

Functions as Data
In JavaScript, however, functions are not only syntax but also data, which means that they can be assigned to variables, stored in the properties of objects or the elements of arrays, passed as arguments to functions, and so on.

var a = square(4);  // a contains the number 16 var b = square;     
// Now b refers to the same function that square does 
var c = b(5);       // c contains the number 25

Functions as Methods
A method is nothing more than a JavaScript function that is stored in a property of an object and invoked through that object. Methods have one very important property: the object through which a method is invoked becomes the value of the this keyword within the body of the method. Thus, when you invoke o.m(), the body of the method can refer to the object o with the this keyword. Here is a concrete example:

var calculator = {       
   // An object literal     operand1: 1, 
   operand2: 1, 
   compute: function() { 
            this.result = this.operand1 + this.operand2; 
   } 
}; 
calculator.compute();       // What is 1+1? 
print(calculator.result);   // Display the result

IMPORTANT: When a function is invoked as a function rather that as a method, the this keyword refers to the global object.
Confusingly, this is true even when a nested function is invoked (as a function) within a containing method that was invoked as a method: the this keyword has one value in the containing function but (counterintuitive) refers to the global object within the body of the nested function. The length property of a function itself, however, has a different meaning. This read-only property returns the number of arguments that the function expects to be passed that is, the number of parameters it declares in its parameter list.

ECMAScript specifies two methods that are defined for all functions, call() and apply(). These methods allow you to invoke a function as if it were a method of some other object. The first argument to both call() and apply() is the object on which the function is to be invoked; this argument becomes the value of the this keyword within the body of the function.

Lexical Scoping
Functions in JavaScript are lexically rather than dynamically scoped. This means that they run in the scope in which they are defined, not the scope from which they are executed. When a function is defined, the current scope chain is saved and becomes part of the internal state of the function. At the top level, the scope chain simply consists of the global object, and lexical scoping is not particularly relevant. When you define a nested function, however, the scope chain includes the containing function. This means that nested functions can access all of the arguments and local variables of the containing function.

The Call Object
When the JavaScript interpreter invokes a function, it first sets the scope to the scope chain that was in effect when the function was defined. Next, it adds a new object, known as the call object (the ECMAScript specification uses the term activation object) to the front of the scope chain. The call object is initialized with a property named arguments that refers to the Arguments object for the function. Named parameters of the function are added to the call object next. Any local variables declared with the var statement are also defined within this object. Since this call object is at the head of the scope chain, local variables, function parameters, and the Arguments object are all in scope within the function. This also means that they hide any properties with the same name that are further up the scope chain, of course. Note that unlike arguments, this is a keyword, not a property in the call object.

Classes, Constructors, and Prototypes
You have also seen other kinds of JavaScript objects created with a similar syntax:

var array = new Array(10); 
var today = new Date( );

The new operator must be followed by a function invocation. It creates a new object, with no properties and then invokes the function, passing the new object as the value of the this keyword. A function designed to be used with the new operator is called a constructor function or simply a constructor. A constructor's job is to initialize a newly created object, setting any properties that need to be set before the object is used.

// Define the constructor. Note how it initializes the object referred to by "this". 
function Rectangle(w, h) { 
   this.width = w; 
   this.height = h; 
   // Note: no return statement here 
}

Notice how the constructor uses its arguments to initialize properties of the object referred to by the this keyword. You have defined a class of objects simply by defining an appropriate constructor function; all objects created with the Rectangle( ) constructor are now guaranteed to have initialized width and height properties. This means that you can write programs that rely on this fact and treat all Rectangle objects uniformly. It turns out that every JavaScript object includes an internal reference to another object, known as its prototype object. Any properties of the prototype appear to be properties of an object for which it is the prototype. Another way of saying this is that a JavaScript object inherits properties from its prototype.
After creating the empty object, new sets the prototype of that object. The prototype of an object is the value of the prototype property of its constructor function. All functions have a prototype property that is automatically created and initialized when the function is defined. The initial value of the prototype property is an object with a single property. This is clearer with an example. Here is the Rectangle( ) constructor:

// The constructor function initializes those properties that 
// will be different for each instance. 
function Rectangle(w, h) { 
   this.width = w; 
   this.height = h; 
} 
// The prototype object holds methods and other properties that 
// should be shared by each instance. 
Rectangle.prototype.area = function( ) { return this.width * this.height; }

This means that the prototype object is an ideal place for methods and other constant properties. When you read property p of an object o, JavaScript first checks to see if o has a property named p. If it does not, it next checks to see if the prototype object of o has a property named p. This is what makes prototype-based inheritance work. When you write the value of a property, on the other hand, JavaScript does not use the prototype object. Therefore, property inheritance occurs only when you read property values, not when you write them.Note that you must never add properties to Object.prototype.

Using closures
closure is a function plus the scope that was in effect when the function was defined.[*] By defining a function, therefore, you can use its local scope as a private namespace. Nested functions defined within the outer function have access to this private namespace. The advantages of this are twofold. First, since the private namespace is also the first object on the scope chain, functions in the namespace can refer to other functions and properties in the namespace without requiring a fully qualified name. The second advantage to using a function to define a private namespace has to do with the fact that it is truly private. There is no way to access the symbols defined within the function from outside the function. Those symbols become available only if the function that contains them exports them to an external, public namespace. What this means is that a module can choose to export only its public functions, leaving implementation details such as helper methods and variables locked up in the privacy of the closure.

// Create the namespace object.  Error checking omitted here for brevity. var com; 
if (!com) com = {}; 
if (!com.davidflanagan) com.davidflanagan = {}; 
com.davidflanagan.Class = {}; 
// Don't stick anything into the namespace directly. 
// Instead we define and invoke an anonymous function to create a closure 
// that serves as our private namespace. This function will export its 
// public symbols from the closure into the com.davidflanagan.Class object 
// Note that we use an unnamed function so we don't create any other 
// global symbols. 
(function( ) {  // Begin anonymous function definition 
    // Nested functions create symbols within the closure 
    function define(data) { counter++; /* more code here */ } 
    function provides(o, c) { /* code here */ } 
    // Local variable are symbols within the closure. 
    // This one will remain private within the closure 
    var counter = 0; 
    // This function can refer to the variable with a simple name 
    // instead of having to qualify it with a namespace 
    function getCounter( ) { return counter; } 
    // Now that we've defined the properties we want in our private 
    // closure, we can export the public ones to the public namespace 
    // and leave the private ones hidden here. 
    var ns = com.davidflanagan.Class; 
    ns.define = define; 
    ns.provides = provides; 
    ns.getCounter = getCounter; 
})( );          // End anonymous function definition and invoke it

Module Pattern

Global variables are evil. Within YUI, we use only two globals: YAHOO and YAHOO_config. Everthing in YUI makes use of members within the YAHOO object hierarchy or variables that are scoped to such a member. We advise that you exercise similar discipline in your own applications, too. Douglas Crockford has been teaching a useful singleton pattern for achieving this discipline, and I thought his pattern might be of interest to those of you building on top of YUI. Douglas calls this the “module pattern.” Here’s how it works:

1. Create a namespace object: If you’re using YUI, you can use the YAHOO.namespace() method:

YAHOO.namespace("myProject");

This assigns an empty object myProject as a member of YAHOO (but doesn’t overwrite myProject if it already exists). Now we can begin adding members to YAHOO.myProject.

2. Assign the return value of an anonymous function to your namespace object:

YAHOO.myProject.myModule = function () {
   return  {
            myPublicProperty: "I'm accessible as YAHOO.myProject.myModule.myPublicProperty.";
            myPublicMethod: function () {
            YAHOO.log("I'm accessible as YAHOO.myProject.myModule.myPublicMethod.");
   }
};

}(); // the parens here cause the anonymous function to execute and return

Note the very last line with the closing curly brace and then the parentheses () — this notation causes the anonymous function to execute immediately, returning the object containing myPublicProperty and myPublicMethod. As soon as the anonymous function returns, that returned object is addressable as YAHOO.myProject.myModule.

3. Add “private” methods and variables in the anonymous function prior to the return statement. So far, the above code hasn’t bought us any more than we could have gotten by assigning myPublicProperty and myPublicMethod directly to YAHOO.myProject.myModule. But the pattern does provide added utility when we place code before the return statement:

YAHOO.myProject.myModule = function () {
                              //"private" variables:
                              var myPrivateVar = "I can be accessed only from within YAHOO.myProject.myModule.";

                              //"private" method:
                              var myPrivateMethod = function () {
                              YAHOO.log("I can be accessed only from within YAHOO.myProject.myModule");
                            }

return  {
   myPublicProperty: "I'm accessible as YAHOO.myProject.myModule.myPublicProperty."
   myPublicMethod: function () {
                      YAHOO.log("I'm accessible as YAHOO.myProject.myModule.myPublicMethod.");

                     // Within myProject, I can access "private" vars and methods:
                     YAHOO.log(myPrivateVar);
                     YAHOO.log(myPrivateMethod());

                     // The native scope of myPublicMethod is myProject; we can
                     // access public members using "this":
                     YAHOO.log(this.myPublicProperty);
                   }
  };
}(); // the parens here cause the anonymous function to execute and return

In the codeblock above, we’re returning from an anonymous function an object with two members. These members are addressable from within YAHOO.myProject.myModule as this.myPublicProperty and this.myPublicMethod respectively. From outside of YAHOO.myProject.myModule, these public members are addressable as YAHOO.myProject.myModule.myPublicProperty and YAHOO.myProject.myModule.myPublicMethod. The private variables myPrivateProperty and myPrivateMethod can only be accessed from within the anonymous function itself or from within a member of the returned object. They are preserved, despite the immediate execution and termination of the anonymous function, through the power of closure — the principle by which variables local to a function are retained after the function has returned. As long as YAHOO.myProject.myModule needs them, our two private variables will not be destroyed.

4. Do something useful with the pattern. Let’s look at a common use case for the module pattern. Suppose you have a list, some of whose list items should be draggable. The draggable items have the CSS class draggable applied to them.

<!--This script file includes all of the YUI utilities:-->
<script type="text/javascript"
src="http://yui.yahooapis.com/2.2.2/build/utilities/utilities.js"></script>

<ul id="myList">
<li class="draggable">Item one.</li>
<li>Item two.</li> <!--item two won't be draggable-->
<li class="draggable">Item three.</li>
</ul>

<script>
YAHOO.namespace("myProject");
YAHOO.myProject.myModule = function () {

//private shorthand references to YUI utilities:
var yue = YAHOO.util.Event,
yud = YAHOO.util.Dom;

//private method:
var getListItems = function () {

                   //note that we can use other private variables here, including
                   //our "yud" shorthand to YAHOO.util.Dom:
                   var elList = yud.get("myList");
                   var aListItems = yud.getElementsByClassName(
                      "draggable",     //get only items with css class "draggable"
                      "li",            //only return list items
                       elList          //restrict search to children of this element
                       );
                  return aListItems;
};

//the returned object here will become YAHOO.myProject.myModule:
return  {

          aDragObjects: [],    // a publicly accessible place to store our DD objects
          init: function () {
                // we'll defer making list items draggable until the DOM is fully loaded:
                yue.onDOMReady(this.makeLIsDraggable, this, true);
          },

          makeLIsDraggable: function () {
                var aListItems = getListItems(); // these are the elements we'll make draggable
                for (var i=0, j=aListItems.length; i<j; i++) {
                   this.aDragObjects.push(new YAHOO.util.DD(aListItems[i]));
                }
}

};
}(); // the parens here cause the anonymous function to execute and return

// The above code has already executed, so we can access the init
// method immediately:
YAHOO.myProject.myModule.init();
</script>

This example is a simple one, and it’s deliberately verbose — if this was all we were doing, we could doubtless write it in a more compact way. However, this pattern scales well as the project becomes more complex and as its API grows. It stays out of the global namespace, provides publicly addressable API methods, and supports protected or “private” data and methods along the way.

Function scope can create an encapsulation. Use an anonymous function to wrap your application.

ПП Понякога не е достатъчно и за бърза справка ползвам това.

За Хенри Милър и други мисли

2007-06-20T16:44:00.002+03:00

Днес се сетих за Хенри Милър. Със сигурност е много подценяван. Хората си правят изводи само като видят обложката на "Sexus", много секс сцени и никаква фабула. Винаги ми е харесвал Хенри Милър! При него няма рамки. Четейки го, се престраших да пиша. Почнах от дълги писма. Трудно е да се пишат, винаги намираш написаното за тривиално. В писмата ми от казармата имаше повече въпроси и никаква интрига. Коресопнденцията ми се превръщаше във въпроси отговори. Стила на Хенри е "течащ". Ето как си представям творческия му делник. Става късно и докато си пие кафето се "хваща" за някоя мисъл и я разтяга докрай. Понякога има огомни скокове от действие към действие и какво от това, в повечето дисциплинирани писатели нямат успех.Почнах да пиша писмата си с много кураж. Оставям се на течението и каквото излезе. В началото дори реших дори да не ги препрочитам. Получаваха се дълги и изпъстрени с тлъсти правописни грешки писма. Хората обичат да си естествен, когато намерят твоя грешка се окуражават и престрашават. Получава се комуникация. Твоите грешки са стимул за друг. Достатъчно ли са умни, за да видят капана? Това ме вълнува! Понякога съм се възползвал от това. Днес имахме интервю. Кога може да ти падне гарда? Какво ще кажеш от един грешащ изпитващ добродушко. От такива може скоро и да си нокдоун. Често включвам тоя трик при воденето на интервюта. Не бих казал, че е подло. Просто техника премесена с чувство за хумор. Греша и чакам реакцията. Задаването на въпроси от рода на "Избройте най-добрите и най-лошите си качества" ме вбесява безкрайно. Бих отоговорил "Най-доброто ми качество е, че не виждам лошите си качества". Клишетата убиват. Изпадаш в друга лига. Ако отговориш с добре заучено клише дали си ценен? Това може да значи - да, ти разбираш, че интервюиращия е тъпанар и му отвръщащ подобаващо или да и аз съм чел тази книга и мога да цитирам безкрай.
Духовитите и интелигентни хора умело лавират и на свой ред те поставят на изпитание. Забавлявам се истински. Винаги се опитвам да открия, какво имат като ценност, което ще е валидно близките 10 години. Не искам да знае перфектени еднодневки, искам да имам личност насреща, която и да умее да се забавлява. Да има идеи, да има мнение. Да е добър човек.
Все се питам дали човек трябва да има две страни преди работа и след работа. Дори и това не е достатъчно. Дали трябва да е многолик? Обичам такива хора. Обичам да откривам различните лица на хората в житейските ситуации. Следя и анализирам, може би дори се и уча. Не случайно има такива максими или там както се казваха, "Човек се познава, когато е на път". Тогава си до него и следиш реакциите. E, човек не се ли познава, когато е по голяма нужа? Явно не е доказано. Изкуството според мен е да знаеш, кога да превключиш. Аз съм открил за себе си че не трябва се застоявам - изнервям се и по-скоро вредя на околните отколкото да им помагам.
Обичам да чета Хенри Милър и това си е.

Daily thoughts - 2

2007-06-05T16:20:00.002+03:00

Макар че съм работил доста с Subversion днес ми се наложи да направя merge и доста се поизпотих. Инсталацията и простичкия commit, update не са всичко. Сценария е trunk, branch-1.2.0 и много учудващо branch-1.2, които е бранч на branch-1.2.0 (не знам кои го е измислил така). Картинката е следната:


+-----------------> branch-1.2
|   Merge ^
|         |
+--------------------------> branch-1.2.0
|
|
trunk --------------------------------------------->

Задачата? Промените от branch-1.2.0 да идат в branch-1.2, но от всичко а от определен момент (commit). Един ден четох как да го направя от команден ред и днес се престраших да експериментирам.

Подготвям си нещата като вземам последните версии на "моя" и "чуждия" branch.

svn update --show-updates

Добре е да има застраховка и затова слагам един таг.

svn copy -m "Tag before merge with branch 1.2.0"  https://svn.company.com/product/branches/1.2  https://svn.company.com/product/tags/release-1.2-M01

После отивам в директорията на "чуждия" branch и искам да видя всички промени от самото създаване на branch-a до сега:

svn log --stop-on-copy -v > changes.log

Същото правя и за "моя" branch, като тука по-специялно ме интересува кога точно в създаден. Най-отдолу пише:

------------------------------------------------------------------------
r3777 | someone | 2007-04-04 18:20:31 +0300 (Wed, 04 Apr 2007) | 1 line
Changed paths:
A /branches/1.2 (from /branches/1.2.0:3776)

Creating branch for development of 1.2.x versions
------------------------------------------------------------------------

Отварям си културно changes.log и почвам да разглеждам. Ахааа ето и версията, от която нататък трябва да взема промените - r3785

Изводите. До r3777 двата branch-a са си еднакви и игнорирам промените. Намирам си версията от която нататък ми трябват промените и се готвя за merge. Все забравям, че HEAD е последната версия а не trunk-a, който е с CVS минало ще ме разбере :)
За merge се задава диапазона и после откъде да се вземе този диапазон. Плахо проверявам с --dry-run от r3785 до сега т.е. HEAD.

cd 
svn merge --dry-run -r3785:HEAD https://svn.company.com/product/branches/1.2.0

А това значи: Дай ми всички промени в branch-1.2.0 от версия 3785 до последната и ги приложи в текущия branch (1.2)

Виждам каво ме чака и се хвърлям в огъня.

svn merge -r3785:HEAD https://svn.company.com/product/branches/1.2.0

U    administration/webroot/waf/layout/porduct/core/services/assets/model/Asset.jsp
U    lib/plica-waf.jar
U    lib/plica-waf-web.jar
U    lib/plica-waf-src.jar
C    core/webroot/skin/i18n/en.js
U    core/webroot/skin/basic2/main.css
A    core/webroot/skin/adb
A    core/webroot/skin/adb/main.css
U    core/webroot/skin/super/main.css
U    core/src/java/product/extensions/reminders/model/display.properties
U    core/src/java/product/core/services/subscriptions/model/display.properties
A    core/src/js/box/adb.js
U    core/src/js/PlaybackManager.js
U    core/src/js/widgets/config.js
U    core/src/js/widgets/epg.js
U    core/src/js/widgets/reminders.js
U    core/src/js/widgets/broadcast.js
?    dir_conflicts.prej

Ух само един конфликт и нещо странно в директорията - dir_conflicts.prej. Лесно се справам с програмния конфликт.

svn resolved core/webroot/skin/i18n/en.js

Как обаче да подходя с dir_conflicts.prej? Първо какво значи това - станало е конфликт в svn properties. Ето и лекарството:

# see what we have
svn proplist .

# see the problem
less dir_conflicts.prej

# find the problem - it was in svn:ignore
svn propedit svn:ignore .

# change svn:ignore (add or remove something). In my case I have to add.
svn propset svn:ignore bin .

# do it
svn resolved .

Съвесно проверявам статуса и разликите:

svn status --show-updates
svn diff |colordiff

изтрелвам всичко

svn commit -m "Merged branch 1.2.0 to branch 1.2"

Все още не мога да свикна с Subversion, защото винаги правя аналогии с CVS-a. Много по-добър от CVS-а! Вижда ми се малко прекалено, ако разбира се ако забравим преименуването на файловете. Другото дразнещо нещо е merge-a. Ако ви се наложи да правите постоянен merge с trunk-a да речем, тогава вие и само вие трябва да държите списък за това от къде до къде сте направили merge. Какво имам в предвид. Ако в понеделник сте направили:

svn merge -r5238:HEAD http://svn.company.com/product/trunk
svm commit -m "merge commit"
Commit at 5302

Трябва да запомните това число 5302 и във вторник да почните точно от там.

svn merge -r5302:HEAD http://svn.company.com/product/trunk

Иначе ще получите много конфликти и пак ще се наложи да ги оправяте ръчно. Subversion просто не държи списък на направените merges и до къде са направени. Запазете вяра обаче в версия 1.5 това ще бъде коригирано. До тогава може да ползвате svnmerge и тези напътствия.
И сега най-инересната част. След като синхронизирам branch-a 3 седмици с trunk и отделно активно се добавя код branch-a идва обратната задача - всичко от този branch да иде обратно в trunk. Много глупаво и напрактика двойна работа, ама нищо приемам го като предизвикателство.

cd trunk
svn merge http://svn.company.com/product/trunk http://svn.company.com/product/branches/1.2 .

с други думи всички разлики(HEAD:HEAD) в текущата директория, която е всъщност trunk-a.

Daily thoughts - 1

2007-05-17T10:06:00.000+03:00

"Just think--you could be rich one day!"

Много често ми се налага да решавам проблеми като търся в Google или питам приятели, колеги и форуми. После минава извесно време и бре, същия проблем. Да, ама как го реших, кого попитах? Та нали затова се водят бележки. Аз дори си имам един файл на Descktop-a - notes.txt. Като направя нещо или видя добро решение си пиша в него. Помага ама не е универсално, вече загубих два такива. Много ми се ще и да споделям, да видя коментари и макар и да звучи егоистично, да си пазя нещата. Другата ми идея е, под този етикет - daily да си споделям настроенията. Нещо кратко, може би интимно. Така ще си стане истински дневник. До сега писанията ми са повече като "статии". Това ми отнема повече време и blog-a ми остава за много време един и същт.

Е това беше анонса. Надявам се да не пиша само няколко реда, като тези в телеграфен стил. Лесно става и води до пристрастяване. Това не трябва да са неща за издатели, а нещо споделено.

How to process dependant tasks

2007-02-04T20:47:00.001+02:00

Математиците казват, че ако можеш да си дефинираш поставената задачата, то тя наполовина е решена. Програмистите се шегуват, че всяко задание е решено тогава и само тогава, когато решението удоволетворява и всички бъдещи изменения на заданието. Вярно е, че непрекъснато се променят условията, но всички го знаят. Затова може би се приема за решение всяко лесно изменимо приложение. Искам да споделя процеса на решение на една задача, с която си играх тези дни. Много малко книги са написани така, че да покажат еволюцията на идеата в главата на автора. Дадени са cool решения и те карат да се подтискаш. Всяко решение си има исторя. Ето и първоначалното "поръчение", което получих:

Получаваш два обеката SuperTask и Task, които са в определено състояние (state). Можеш да изпълниш SuperTask само при условие, че можеш да доведеш Task до състояние "Complated". Състоянията са две - Completed, NotStarted.

Тъй като тази структура не е нищо особенно я аз мога да се справя мнооо лесно като напиша нещо от рода на (примерно):


.....
Task task = superTask.getChildTask();
if (Task.COMPLATED_STATE.equals(task.getStatus())) {
    superTask.process();
} else {
    log.debug("Child task is not ready..");
    // do something else
}
.....

Е, какво пък толкова - върши работа и е добре четимо. Много се чудя на колеги, които гадаят какво може да се случи и залитат в една посока. Не знам дали ви се е случвало такова нещо. И после какво, идва новото задание и наистина е интересно да се гледа реакцията. Ами когато сочи в друга посока? За да се докаже човек прави и "задни салта" за промяна на кода и нито крачка назад. Понякога тази крачка е и невъзможна ако "новата посока" прекалено късно и върху "гадаенето" са се понатрупали досна нови добавки. Затова аз съм си за принципа KISS - Keep it Simple Stupid. Така си винаги в посоката, в която духне вятъра.
Не закъснява и промяната:

SuperTask може да има и повече от един Child. За да може да се обработи всички Child трябва да са в Completed. Няма промяна на броя на състоянията.

Та като говорим за вятъра, каква може да е посоката. Ами ако се увеличава броя на Task? О, не е "big deal" си казвам нали има цикъл for. Слагам for и си свиркам, вместо за ден аз се оправям за час. Па и шефа доволен. Обаче мамка му ако се променят броя на състоянията - закивам. Тогава ще стане едно if ... else няма оправяне. Може да се достигне до нещо от рода на:


if(STATUS_COMPLETED.equals(this.status)) return false;
...     
if(taskFromSf.getStatus()!= null && !taskFromSf.getStatus().equals(status)){
...
}
if(STATUS_VERIFICATION.equals(status)){
....   
}

Аз никак не мога да се оправям с такъв "хоп-хоп" код. Все му губя нишката. А и тестването става нещо ужасно. При това условие ще влезе в този if, а иначе в онзи. Ами нали уж Java, нали уж обекти джиджи-биджи. Не искам блок-схеми решение. И в един момент уж последното задание направо настръхнах:

Child могат да имат повече от две състояния - цели 4 (NotStarted, Verivication, Activating, Completed)

Казах си стига! И започнах да мисля как да пооправя нещата. Тъй като всичко е на английски в началото залитнах като се хванах за думичката "state". Не е ли очевидно - "State Pattarn". Цял ден експлоатирах идеята. Да ама не. Получи се нещо ама беше извратено. Аз се занимавам с Таsk процедирам с него, по определен начин. Няма ли да е добре да се съберат всияки операции върху този обект на едно място. Да кажа:


task.process();

и в зависимост от състоянието на Task, process да реаргира по различен начин. Леле и на това ако не му се вика polymorphism. Един обект да има много(poly-) форми (-morphism). После ми изникна примерчето от една книжка - много видове криптиране и всеки в отделен клас. И тогава:


file.crypt();

и в зависимост от това какъв ТИП (= STATE) e file, crypt() реаргира по различен начин. Главата в книгата беше озаглавена "Strategy Pattern". Добре де, ама защо да избера него. Един пасаж ме убеди:


To alter the behavior of the context (file.crypt()), a client object needs to 
configure the context with the selected strategy instance. This type of 
arrangement completely separates the implementation of an algorithm from the context that uses it. 

As a result, when an existing algorithm implementation is changed or a new algorithm
 is added to the group, both the context and the client object (that uses the context) remain unaffected.

Хехе ами да ми дават колкото си състояния тогава аз ще си ги отделям и ще им имплементирам специфичен process() метод (..и други ако трябва). Важно е да четеш "правилините" книги, ей.


               +--------------+                +----------------+
               |     State    |                | TaskWorkflow   |     
               |              | <--------------|  (Contex)      |
               +--------------+                +----------------+
                  /       \
                 /  ...    \
                /           \
     +----------------+      +----------------+
     |VerificationTask|      | ActivationTask |
     |                |      |                | 
     +----------------+      +----------------+

Мога да отделя всичко не е късно. Радвам се. Внимателно си подбирам интерфейсите и систематизирам нещата:


interface SystemInterface {

    // our specific operations 
    void escalate(); 
    void persist();
    void reverse();
}

interface State extends SystemInterface {

    // Possible states
    String NOTSTARTED_STATE = "Not Started";
    String ACTIVATION_STATE = "Activation";
    String VERIFICATION_STATE = "Verification";
    String COMPLATE_STATE = "Complate";

    // workflow operaion
    void process();
}

public class NotStartedState implements State ...
public class ActivationState implements State ...
public class ValidationState implements State ...
public class ComplatedState implements State ...

Пфуу усетих се навреме. Готов съм да посрешна следващата буря, нещата се подредени и най-важното всеки след мен ще ги разбере. Знам къде какво ме чака и знам къде да го намеря. За десерт са ми оставили нещо специално:

Всеки Task може да има също наследници и те наследници...демек до безкрай. Task отива в Completed т.и.с.т.к всички негови наследници са достигнали Complete. И най-потресаващото, че една задача може да е преди друга.

Много ме обърка последното изискване - признавам.
Както са ме е учил другаря Цанков по математика, бързам да онагледя нещата:


               +--------------+
               |  Super Task  |
               |              |  ROOT
               +--------------+
                  /       \
                 /   ...   \
                /           \
               *             *
     +--------------+   +--------------+
     | Child Task 1 |   | Child Task 2 |
     |(Verification)|   | (Activating) |   LEVEL 1
     +--------------+   +--------------+
             /                \
            /        ...       \
           /                    \
          *                      *
   +--------------+     +--------------+
   | Child Task 3 |     | Child Task 4 |
   | (NotStarted) |     | (Completed)  |   LEVEL 2
   +--------------+     +--------------+

Така такаааа, почват разсъжденията по картинка. Имам ги типовите операции значи сега трябва да се средоточа по обхождането на дървото, което в крайна сметка се получи. След като има предусловие трябва да почна от долу-нагоре. Рекурсия ще играе тука момче, но след Lisp закалката само се усмихвам под (заченка на) мустак. Важно е да се уточни тука и как се изгражда дървото и как работя с него. Като дадено имам SuperTask и после започвам да закачам един вид "условията" - Task. Така че, в Task имам:


    public void addChildTask(TaskObj child) {

        assert child != null;

        child.setParentTask(this);
        childTasks.add(child);
    }

Искам да кажа, че аз сам си изграждам дървото. Добре де, аз не моооо ли да кажа getAllChildTask(). Мога, ето как:


    public List<TaskObj> getAllChildTasks() {

        List<TaskObj> taskStack = new ArrayList<TaskObj>();

        Iterator<TaskObj> subTasks = childTasks.iterator();
        while ( subTasks.hasNext() ) {
            taskStack.addAll(subTasks.next().getAllChildTasks());
        }
        
        taskStack.add(this);
        
        return taskStack;
    }

Докато си пусках тестовете видях, че греша и добавям и смия SuperTask. Обаче ме осени следната идея: това не е ли ми дава и реда на изпълнение на task.process()? Не ми ли дава свобода да се "движа" навсякъде с SuperTask и спокоино да си вземам обектите, към които има referece? Ами да!


Call stack
+--------------------------+
| 3 | 4 | 1 | 2| SuperTask |
+--------------------------+

Е, не са в идеален ред, но за мен е важно, че е спазен реда на извикване по нива LEVEL2, LEVEL1, ROOT. За реда(кой преди кой) на обработването на Task се получи някак естествено, след като аз си изграждам дървото, който е по-напред е по-дълбоко в йерархията и точка. Ами май май това е. За сега няма ново поръчение.

Малко изводи да си направим сега. Всеки програмист се влияе от кода написан преди него. Ако аз бях видял нещо от рода на:


  while(salesOrders.hasNext()){ 
    SalesOrder salesOrder = salesOrders.next();
    Iterator services = salesOrder.getProduct().getServices().iterator();
    while(services.hasNext()){
      Service service = services.next();
      Iterator resources = service.getResources().iterator();
      while(resources.hasNext()){
        Resource resource = resources.next();
        if(resource.getValue()!=null) continue;
      
        boolean automated = lookup.isResourceAutomatic(resource.getName());
        String hashKey = automated+"/"+ service.getRfsName()+"/"+ resource.getRoleQueue();
        TaskObj workTaskObj = tasksInMotion.get(hashKey);
        if(workTaskObj==null || workTaskObj.getResources().size()==9){
          TaskObj newWorkTaskObj =  new TaskObj(
     ....

от мен какъв код се очаква за бога? Добър програмист не е този, който може да го чете, а този който не го допуска. Хората по природа са мързеливи и тръгват по пътя с най-малко съпротивление. Когато се поставят и срокове ставата гадни хакове. Прихващаме бързо лошите неща. Когато един софтуер започне да се "крепи" в крайна сметка се получава по-зле и по-зле и по-... Това, че рефакторираш използвайки Extract Method и Rename е като да си подменяш плочките на банята в къща без основи. Това е началото на края. Далече от това! Важното е да направиш промяната навреме, да евоюираш заедно с посоката на заданията. И другото е да атакауваш проблема в неговата основа, а не да се търсят заобикони пътища. Ako да речем ми трябва и точен ред на извикване няма да се опитвам да променям целия workflow, а ще потърся начин да изградя самата структура по-добре. Task се взема/слага в базата през Hibernate. Тогава сменям част от кода на Hibernate и имам:



<!--  Relation Foreign key  -->
<many-to-one name="parentTask" class="TaskObj"
          foreign-key="FK_TASK_PARENT_ID" lazy="false">
 <column name="PARENT_TASK_ID" not-null="false" />
</many-to-one>

<bag name="childTasks" cascade="all" lazy="false">
 <key column="PARENT_TASK_ID" />
 <one-to-many class="TaskObj" />
</bag>

вместо:
.............
<set name="childTasks" cascade="all" lazy="false">
 <key column="PARENT_TASK_ID" />
 <one-to-many class="TaskObj" />
</set>

и вече разполагам с List интерфейс, вместо с Set и мога лесно да променя "Call Stack"-a.


    public Stack<TaskObj> getDependenciesCallStack() {

        Stack<TaskObj> taskStack = new Stack<TaskObj>();

        for ( TaskObj child : getChildTasks() ) {
            taskStack.push(child);
            taskStack.addAll(child.getDependenciesCallStack());
        }
        
        return taskStack;
    }

Винаги съм подозрителен и затова решавам да си направя визоализация на дървото от задачи:


    private int currentPosition = 0;
    private final StringBuffer listTask = new StringBuffer(100);

    private static final int INDENT_STEP = 5;

    /**
     * Display(first) TaskObj taskId and subject in a tree structure
     */
    public void dumpTaskTree() {

        // display title
        listTask.append("\n============================\n");
        listTask.append("(ROOT) ").append(this.getSubject()).append('\n');

        final Set subtasks = this.getChildTasks();
        final Iterator tIter = subtasks.iterator();
        while ( tIter.hasNext() ) {
            final TaskObj metaTask = (TaskObj) tIter.next();

            // Task properties that I need
            listTask.append("   !-- ");
            listTask.append(metaTask.getSubject());
            listTask.append('(');
            listTask.append(metaTask.getId());
            listTask.append(", ");
            listTask.append(metaTask.getStatus());
            listTask.append(")\n");

            subTasksDraw(metaTask, INDENT_STEP);
        }

        log.debug(listTask.toString());
    }


    /**
     * Draw childes task(rest) of a meta task if they exist
     * 
     * @param metaTask
     * @param shift
     *            indentation step
     */
    private void subTasksDraw(final TaskObj metaTask, final int shift) {
        final Set subtasks = metaTask.getChildTasks();
        final Iterator tIter = subtasks.iterator();

        while ( tIter.hasNext() ) {
            final TaskObj aTask = (TaskObj) tIter.next();

            currentPosition = currentPosition + shift;
            for ( int i = 0; i < currentPosition; i++ ) {
                listTask.append("  ");
            }

            listTask.append("\\+--- ");
            listTask.append(aTask.getSubject());
            listTask.append('(');
            listTask.append(aTask.getId());
            listTask.append(", ");
            listTask.append(aTask.getStatus());
            listTask.append(")\n");

            subTasksDraw(aTask, shift);
        }
        currentPosition = 0;
    }

И последно: "Premature optimization is the root of all evil."

ПП.
Той: "Добро утро, ще можите ли да добавите и друг тип обекти към SuperTak, освен Task?"
Аз: "Да. Чували ли сте за Visitor Pattern?"
Той: "А може ли ..." (внезапно изгубва съзнание и диалога прекъсва)

Lisp environment

2006-11-12T16:45:00.002+02:00

Средата за разработка е била винаги важна и затова доста си играя с настройките. Все искам кода да е добре подреден, да имам лесен начин да достъпвам документацията, да има code completion и разни други глезотийки. Така и стана с Lisp средата за разработка. Просто задължителните неща са: SBCL, Linux и Emacs. Въпроса е как ще напаснем тези три неща и колко бързо ще свикнем с Emacs.
Аз използвам Debian и нещата, които се инсталират допълнително са:

sudo aptitude install sbcl
sudo aptitude install w3
sudo aptitude install w3-el-e21
sudo aptitude install hyperspec
sudo aptitude install emacs-goodies-el

Другото "важно" е да се смени клавишната комбинация за превключване от/към кирилица. В emacs "alt-shift" e много застъпена, така че "alt-alt"(Gnome default) или "ctrl-ctrl" e за предпочитане.
Аз не обичам много да пиша така,че искам да използвам и history-то на REPL-a. Както в моя shell. Като изплзвам стрелките да виждам какво е било. Затова инсталирам linedit:

> sbcl
* (require :asdf-install)
* (asdf-install:install :linedit)   ;first-time installation only

* (require :linedit)                ;if already installed
* (linedit:install-repl)

Готови ли сте и за моя dot.emacs:

;;; Can use now Common Lisp functions                                                                                                                                                                
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;                                                                                                                                                             

(require 'cl)                                                                                                                                                                                        

;;; Art                                                                                                                                                                                              
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;                                                                                                                                                             

(set-background-color "black")                                                                                                                                                                       
(set-face-background 'default "black")                                                                                                                                                               
(set-face-background 'region "black")                                                                                                                                                                
(set-face-foreground 'default "white")                                                                                                                                                               
(set-face-foreground 'region "gray60")                                                                                                                                                               
(set-foreground-color "white")                                                                                                                                                                       
(set-cursor-color "red")                                                                                                                                                                             

;;; System settinngs                                                                                                                                                                                 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;                                                                                                                                                             

;; Misc customizations                                                                                                                                                                               
(setq inhibit-startup-message t)        ;no splash screen                                                                                                                                            

(auto-compression-mode t)               ;turn on auto file uncompression                                                                                                                             

(menu-bar-mode 0)                       ;turn off unused UI                                                                                                                                          

(setq tab-width 4)                      ;tab size                                                                                                                                                    

(setq display-time-24hr-format t)       ;display the current time                                                                                                                                    
(display-time)                                                                                                                                                                                       

(global-font-lock-mode t)               ;colorize all buffers                                                                                                                                        
(setq font-lock-maximum-decoration t)                                                                                                                                                                

(show-paren-mode t)                     ;highlight parens                                                                                                                                            
(defconst query-replace-highlight t)    ;highlight during query                                                                                                                                      
(defconst search-highlight t)           ;highlight incremental search                                                                                                                                
(transient-mark-mode t)                 ;higlight the marked region (C-SPC)                                                                                                                          

;; Some useful key bindings                                                                                                                                                                          
(global-set-key [home] 'beginning-of-line)                                                                                                                                                           
(global-set-key [end] 'end-of-line)                                                                                                                                                                  

;; Column & line numbers in mode bar                                                                                                                                                                 
(column-number-mode t)                                                                                                                                                                               
(line-number-mode t)                                                                                                                                                                                 

(setq frame-title-format "%b")          ;set title to buffer name                                                                                                                                    

;; Ediff customizations                                                                                                                                                                              
(defconst ediff-ignore-similar-regions t)                                                                                                                                                            
(defconst ediff-use-last-dir t)                                                                                                                                                                      
(defconst ediff-diff-options " -b ")                                                                                                                                                                 

(setq dired-listing-switches "-l")      ;better list display                                                                                                                                         
(setq ls-lisp-dirs-first t)             ;display dirs first in dired                                                                                                                                 

;; Specify where backup files are stored                                                                                                                                                             
(setq backup-directory-alist (quote ((".*" . "~/.backups"))))                                                                                                                                        

(setq custom-file "~/.emacs-custom.el") ;what to load if error                                                                                                                                       
(load custom-file 'noerror)                                                                                                                                                                          

;; Type brackets in pairs                                                                                                                                                                            
(setq skeleton-pair t)                                                                                                                                                                               
(global-set-key (kbd "[") 'skeleton-pair-insert-maybe)                                                                                                                                               
(global-set-key (kbd "{") 'skeleton-pair-insert-maybe)                                                                                                                                               
(global-set-key (kbd "\"") 'skeleton-pair-insert-maybe)

;;; Common Lisp                                                                                                                                                                                      
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;                                                                                                                                                             

;; Specify modes for Lisp file extensions                                                                                                                                                            
(setq auto-mode-alist                                                                                                                                                                                
(append '(                                                                                                                                                                                     
("\\.lisp$" . lisp-mode)                                                                                                                                                             
("\\.lsp$" . lisp-mode)                                                                                                                                                              
("\\.cl$" . lisp-mode)                                                                                                                                                               
("\\.asd$" . lisp-mode)                                                                                                                                                              
("\\.system$" . lisp-mode)                                                                                                                                                           
)auto-mode-alist))                                                                                                                                                                   

;; SLIME and generic Common Lisp.                                                                                                                                                                    
(require 'slime)                                                                                                                                                                                     

(setq slime-edit-definition-fallback-function 'find-tag)                                                                                                                                             

(setq inferior-lisp-program "sbcl"                                                                                                                                                                   
lisp-indent-function 'common-lisp-indent-function                                                                                                                                               
slime-complete-symbol-function 'slime-fuzzy-complete-symbol                                                                                                                                     
common-lisp-hyperspec-root "file:/usr/share/doc/hyperspec/" ;; Debian                                                                                                                           
slime-startup-animation t)                                                                                                                                                                      

(add-hook 'lisp-mode-hook (lambda () (slime-mode t)))                                                                                                                                                
(add-hook 'slime-repl-mode-hook (lambda () (slime-mode t)))                                                                                                                                          
(add-hook 'inferior-lisp-mode-hook (lambda () (inferior-slime-mode t)))                                                                                                                              

(defun customised-lisp-keyboard()                                                                                                                                                                    
(local-set-key [C-tab] 'slime-fuzzy-complete-symbol)                                                                                                                                               
(local-set-key [return] 'newline-and-indent))                                                                                                                                                      

(add-hook 'lisp-mode-hook 'customised-lisp-keyboard)                                                                                                                                                 

(global-set-key "\C-cs" 'slime-selector)                                                                                                                                                             

;; Search in lispdoc.org                                                                                                                                                                             
(defun lispdoc ()                                                                                                                                                                                    
"Searches lispdoc.com for SYMBOL, which is by default the symbol                                                                                                                                   
currently under the curser. Use M-x lispdoc"                                                                                                                                                         
(interactive)                                                                                                                                                                                      
(let* ((word-at-point (word-at-point))                                                                                                                                                             
(symbol-at-point (symbol-at-point))                                                                                                                                                         
(default (symbol-name symbol-at-point))                                                                                                                                                     
(inp (read-from-minibuffer                                                                                                                                                                  
(if (or word-at-point symbol-at-point)                                                                                                                                                
(concat "Symbol (default " default "): ")                                                                                                                                         
"Symbol (no default): "))))                                                                                                                                                      
(if (and (string= inp "") (not word-at-point) (not                                                                                                                                               
symbol-at-point))                                                                                                                              
(message "you didn't enter a symbol!")                                                                                                                                                       
(let ((search-type (read-from-minibuffer                                                                                                                                                       
"full-text (f) or basic (b) search (default b)? ")))                                                                                                                     
(browse-url (concat "http://lispdoc.com?q="                                                                                                                                                  
(if (string= inp "")                                                                                                                                                 
default                                                                                                                                                          
inp)                                                                                                                                                       
"&search="                                                                                                                                                       
(if (string-equal search-type "f")                                                                                                                           
"full+text+search"                                                                                                                                       
"basic+search")))))))
;; Fontify *SLIME Description* buffer                                                                                                                                                                
(defun slime-description-fontify ()                                                                                                                                                                  
"Fontify sections of SLIME Description."                                                                                                                                                           
(with-current-buffer "*SLIME Description*"                                                                                                                                                         
(highlight-regexp                                                                                                                                                                                
(concat "^Function:\\|"                                                                                                                                                                         
"^Macro-function:\\|"                                                                                                                                                                   
"^Its associated name.+?) is\\|"                                                                                                                                                        
"^The .+'s arguments are:\\|"                                                                                                                                                           
"^Function documentation:$\\|"                                                                                                                                                          
"^Its.+\\(is\\|are\\):\\|"                                                                                                                                                              
"^On.+it was compiled from:$")                                                                                                                                                          
'hi-green-b)))                                                                                                                                                                                  

(defadvice slime-show-description (after slime-description-fontify activate)                                                                                                                         
"Fontify sections of SLIME Description."                                                                                                                                                           
(slime-description-fontify))                                                                                                                                                                       

;; Use W3M                                                                                                                                                                                           
(require 'w3m)                                                                                                                                                                                       

(defun w3m-browse-url-other-window (url &optional newwin)                                                                                                                                            
(interactive                                                                                                                                                                                       
(browse-url-interactive-arg "w3m URL: "))                                                                                                                                                         
(let ((pop-up-frames nil))                                                                                                                                                                         
(switch-to-buffer-other-window                                                                                                                                                                   
(w3m-get-buffer-create "*w3m*"))                                                                                                                                                                
(w3m-browse-url url)))                                                                                                                                                                           

(setq browse-url-browser-function                                                                                                                                                                    
(list (cons "^ftp:/.*"  (lambda (url &optional nf)                                                                                                                                             
(call-interactively #'find-file-at-point url)))                                                                                                                      
(cons "."  #'w3m-browse-url-other-window)))                                                                                                                                          

;;; JavaScript                                                                                                                                                                                       
;;; http://web.comhem.se/~u34308910/emacs.html#javascript                                                                                                                                            
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;                                                                                                                                                             

(autoload 'javascript-mode "javascript" nil t)                                                                                                                                                       
(add-to-list `auto-mode-alist `("\\.js\\'" . javascript-mode)) 

;;; Helper functions                                                                                                                                                                                 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Сега нещата стоят по друг начин, писането на Lisp е песен. Ето и командите, които най-често използвам:

LISP RELATED

; Parants
M-( Prints ()

; Compilation
C-c M-k slime-compile-file
C-c C-c slime-compile-defun

; Evaluation
C-M-x slime-eval-defun

; Documentation
C-c C-d a slime-apropos
C-c C-d h slime-hyperspec-lookup
C-c C-m slime-macroexpand-1

; Cross-reference
C-c C-w r slime-who-references

; Manage Slime
M-x slime start slime
C-c C-c slime compile defun
C-c C-k slime compile and load file
C-c M-g slime quit

C-c C-t slime clear repl
M-p slime prev command
M-n slime next command

M-r slime search prev commands
M-s slime search next commands

C-c C-z go to lisp buffer
C-c C-q close all parens

Ето един много добър линк за Emacs командите: Beyond Emacs Tutorial

Oстана да се добави малко творчество и нещата добиват завършен вид. Горе долу подхода ми е следния:

1. Всичко(functions, classes, special variables, and constants) го слагам в defun, за да мога лесно да го проверя дали има грешки с С-с С-с. Ако нещо много ме усъмни(да проверя нещо как работи) се прехвърлям на REPL с C-c C-z и го изпълнявам.

2. Програмата трябва да е lоаdable, сиреч да не се прави нищо допълнително, за да може да се стартира самостоятелно. Ако програмата да кажем, че се казва proba.lisp не ползва допълнителни библиотеки, тогава няма нищо за правене. По-сложнен е другия случай, да иска. Да кажем ползва cl-ppcre. Тогава в кода има:

(defpackage #:proba
(:use #:cl #:cl-ppcre))

Това само по себе си не е достатъчно. Ако направим:

(load (compile-file "proba"))

Получаваме следната грешка: The name "CL-PPCRE" does not designate any package. Ха сега де.
По някакъв начин трябва да съм сигурен, че cl-ppcre ще се зареди и компилира преди моя файл proba.lisp. Най-лесния вариант е да изплзвам ASDF. Създавам един файл proba.asd и в него слагам:

(asdf:defsystem #:proba
:depends-on (#:cl-ppcre)
:components ((:file "proba")))

Ако пък работя в REPL-a ще използвам: ,load-system или (asdf:oos 'asdf:load-op 'proba)

3. Ами ако проета от един файл нарасне и стане проект? Тогава ще се наложи да разделяме на малки файлове и да ги "вържем" по някакъв начин. Да речем proba.lisp нарасне много и аз реша да го рефакторирам и изкарам някои операции в друг файл - operations.lisp. За целта ще се наложи да работя с пакети. Създавам файла package.lisp и в началото на proba.lisp и operations.lisp указвам, на кой пакет пренадлежат.

(in-package #:proba)

Послендия файл ще изглежда малко променен:

(asdf:defsystem #:proba
:depends-on (#:cl-ppcre)
:components ((:file "package")
(:file "operations"
:depends-on ("package"))
(:file "proba"
:depends-on ("package"
"operations"))))

4. Приготвям се за финиширане като се попитам: А какви са нещата от проекта, които могат да се използеват дирекно(кои са интерфейсите)? Определям ги и променям пакетната дефиниция в package.cl:

(defpackage #:proba
(:use #:cl #:cl-ppcre)
(:export #:blah
#:blah2
#:useful-thing3
#:*logfile-directory*))

5. И накрая малко хитрости. Винаги стартирам проета си от неговата директория. Ако съм направил нещо наистина полезно правя нещата още по-глобални като линквам .asd в ~/.sbcl/systems/.

cd ~/.sbcl/system
ln -s ../../Lisp/proba/proba.asd .

Така много лесно мога да си ползвам проета отвсякъде като пиша просто:(require 'proba). Или ако от друг проект ми притрябват моите "полезни" неща от proba. Просто:

(asdf:defsystem #:useful_thing3
:depends-on (#:proba #:drakma)
:components (...))

В общи линии така върви моя Лисп път.

Update(15.12.2009: Нещата в моя .emacs непрекъснато се променят в затова реших да ги сложа тук

Мисли, не казани

2006-10-31T03:17:00.001+02:00

Много от нещата тръгнаха от тази невинна снимка, направена преди много много години. Гледах я и мислите се заредиха. Връщах се многократно в моето щастливо детство. Първо спомени, после тъга. Един толкова обикновен мой портрет от социалистическата детска градина.
Знаех ли какво ме чака? Имах ли представа, колко много ще се променя? Шеметно детство в малкя град, заобиколен с много приятели и любов. Още ме грее този спомен.

Thoughts on HFSC

2006-10-19T14:13:00.000+03:00

Реших да напиша стятия за PF ама то като гледам с каква скорост се развивата няма да стане скоро. Затова ще опитам да си разясня HFCS планировчика. Ще поясня основните неща, оптимизацията и "хватките" са си ваше дело.

Откъде идва името HFSC? Това е съкращение на Hierarchical Fair Service Curve Algorithm. Ето и каква е идеята. Добре е планировчика да се самонаглася и да взема рашения според случая - selfadopted.
В HFSC има ДВА планировчика(packet schedularas). Първия е гарантирания или т.н. realtime, а втория linkshare. HFSC ще избере автоматично, коj от двата ще използва ako на места параметрите се препокриват. Параметрите, които контролират тези два планировчика са:

realtime - той контролира минималната ширина (bandwidth), която се изисква от опашката. Когато има възможност HFSC предпочита този, той е default. Големината му ще нараства докато се достигне лимита на канала или се достигне upperlimit ограничението. Ако нямаме realtime планировчик или "интернета" ни е малко и не можем да гарантираме нужния минимум, ще се използва linkshare. Този параметър e опционален.

Още по нагледно:


   if (there is an eligible packet)
      /* real-time criteria */
      send eligible packet with min. deadline d ;
   else
      /* link-sharing criteria */
      send packet with min. virtual time v ;

linkshare - той определя колко да се вземе трафика за текущата от опашката баща (parent queue). Разпределя пропорционално интернета. Ако имаме излишък той ще се използва според допълнителните параметри или докато се достигне upperlimit (ako e упоменат). И този параметър е опционален.

Mалко по особено е. Където са дефинирани realtime и linkshare и параметрите в тях се препокриват ще се предпочете realtime. Realtime е планировчика по подразбиране. И още нещо, ако в дефиницията на опашката (а не в altq) не се използва linkshare задължително трябва да се напише bandwidth! В противен случай pfctl ще се оплаче. Запомнете го, макар май се промени това в новите версии на pf.

Надлежно показвам какво съм видял в кода:


  ls - linkshare
  rt - realtime
  ul - upper limit

  /* if link_share is not specified, use bandwidth */
  if (opts->lssc_m2 == 0)
     opts->lssc_m2 = pa->bandwidth;

  if ((opts->rtsc_m1 > 0 && opts->rtsc_m2 == 0) ||
      (opts->lssc_m1 > 0 && opts->lssc_m2 == 0) ||
      (opts->ulsc_m1 > 0 && opts->ulsc_m2 == 0)) {

     warnx("m2 is zero for %s", pa->qname);
     return (-1);
  }

Пример:


altq on $ext_if hfsc bandwidth 45Mb   
  queue{dns, ssh, www, mail, other}
     queue dns bandwidth 10%
     queue ssh bandwidth 10%
     queue mail bandwidth 20%
     queue www bandwidth 40%
     queue other hfsc(default)

upperlimit - това е максималното количество "интернет", което някоя от опашките може да използва. И още нещо, което се разбира ама аз да си го кажа: Стойността на upperlimmit трябва да е по-голяма от лимитите поставени в realtime и linkshare. Този параметър е опционален.

Нуждаем се и от малко теория. Ето и необходимата порция.
След всеки един от тези параметри има число, което указва каква част от интернет потока трябва да се задели или от следните 3 числа (m1 d m2). Какво заначат тези числа

m1 - първоначалното количество интернет.
d - забавянето (time delay, in milliseconds)
m2 - корекция на количеството интернет

Тези параметри определят така наречената "сервизна крива" (service curve). Tя може да бъде два типа:
изпъкнала (convex) при m1 > m2
вдлъбната (concave) при m1 < m2.

ВАЖНО:
1) realtime параметрите не могат да бъдат по-големи от 75% от целия ни интернет (total interface bandwidth)
2) кривата на realtime трябва да е винаги изпъкнала (m1 > m2).

Да онагледим нещата:


# PARENT QUEUE DEFINITION
altq on $ext_if hfsc bandwidth 45Mb   
  queue{dmznet, prvnet, others}

# CHILD QUEUE DEFINITIONS
# ако пакетите се задържат до 10 сек. ще вземе 50% или повече
# от цялия интернет. Когато пакетите пристигат повече и повече и
# планировчика ги задържа повече от 10 сек. ще се опита да се коригира
# и завземе 65% от интернета.
  queue dmznet hfsc(linkshare (50% 10000 65%))

# и тук е същото, само че ще се коригира към по-малко!
  queue prvnet hfsc(linkshare (40% 5000 25%))
  queue others hfsc(default)

Нека да поясним нещата. Може да разглеждате опашките като скачени съдове, едното е за сметка на другото. Затова сумата от параметрите от един вид не трябва да надвишават количеството интернет (total bandwith) като default опашката не влиза в тия сметки. Тези стойности могат да са %, b, Kb, Mb, Gb.

Да направим анализ. Да кажем, че в DMZ зоната има FTP сървър и в един момент почва да бълва трафик и "тръбата" от 50% не може да смогне (бави пакетите повече от 10 сек.) затова планировчика я разширява автоматично. Разширяването е за сметка обаче на privnet. Защо съм сложил съм 5 сек? Расъждавам така, ако някое типче тръгне да сваля нещо ще запълни "тръбата" и аз ще го резна като изрично намаля капациета. Второ, ако забавянето е повече от 5 сек. то някъде другаде(в случая dmz зоната) става нещо, трябва повече интернет. Хм, за оптимизацията се разбрахме не мога да кажа точно какво трябва да е забавянето (delay).
Запамети. Горната граница на разширяването може да се ограничи единствено от upperlimit.

Нещата стават още по-интересни, когато намесим и realtime. Kакто ви казах могат да бъдат дефинирани едновременно. HFSC автоматично ще избере, кои ще свърши по-добра работа. Може да изберете да имат еднакви параметри, може и да измислите нещо по-хитро. Дерзайте, но не забравяйте, че сервизната крива на realtime винаги трябва да бъде изпъкнала (m1 > m2). И от тук и простичкото правило: ако искате при забавяне да увеличите канала - linkshare, ako не - realtime.

Пример:


# PARENT QUEUE DEFINITION
altq on $ext_if hfsc bandwidth 45Mb
  queue{dmznet, prvnet, others}

# CHILD QUEUE DEFINITIONS
  queue dmznet hfsc(linkshare (50% 10000 65%))
 
  # HFSC ще избере сам.
  queue prvnet hfsc(realtime (40% 5000 25%) linkshare (40% 5000 25%))
  queue others hfsc(default)

И остана последно смятането на количествата интернет. Сравнете следните два примера:


# CBQ
altq on $ext_if cbq bandwidth 20Mb    queue{dmznet, prvnet, others}

 # prvnet gets 8Mb
 queue prvnet bandwidth 40% queue{host1, host2}
    # host1 gets 4Mb
    queue host1 bandwidth 50%

    # host2 gets 4Mb
    queue host2 bandwidth 50%

# HFSC
altq on $ext_if hfsc bandwidth 20Mb    queue{dmznet, prvnet, others}

  # prvnet gets 8Mb
  queue prvnet hfsc(linkshare 40%) queue{host1, host2}
     # host1 gets 4Mb
     queue host1 hfsc(linkshare 20%)

     # host2 gets 4Mb
     queue host2 hfsc(linkshare 20%)

Какво се забелязва? CBQ разпределя параметрите спрямо parent опашката, а HFSC спрямо root! Много често се греши внимавайте!

Искам да спомена и един друг параметър, който често пипам qlimit. Той определя колко да е голяма опашката и от там колко гладко да се обработва. По подразбиране е 50 пакета. Преди да правите радикални промени поиграйте си с qlimit.


queue oRel  bandwidth 128Kb qlimit 100  hfsc( linkshare 128Kb ) { oRelTCP, oRelUDP }       
       queue oRelTCP bandwidth 64Kb qlimit 60 hfsc( linkshare 64Kb default red )            
       queue oRelUDP bandwidth 64Kb qlimit 60 hfsc( linkshare 64Kb)

Какво да използваме? Ако искаме да сортираме трафика по приоритет ще се възползваме от PRIQ. Ако искаме да разпределим нещата "на калпак" - CBQ. И накрая ако искаме всичко това плюс разни други красиви добавки HFSC.

The Zen of LISP clusure

2006-10-12T15:28:00.000+03:00

Definitions:
A function plus its enviroment is called a closure.

A closure typically comes about when one function is declared entirly within the body of another, and inner function refer to local variables of the outer function.

Example:


(defparameter *fn* 
 (let ((count 0))
  #'(lambda () (setf count (1+ count))))) ; function closure.

count is lambda enviroment( or lambda use count ).

Possible usage: Closures can be used for modularity so you don't have to encapsulate data in classes to prevent it from becoming global.

Тhe names introduced by a LET form turns out not to be a name binding to some immutable values. The names refer to local variables! Such variables(a.k.a lexical variables) follow typical lexical scoping rules, so that LISP always looks up the innermost variable definition when a variable name is to be evaluated.

Example:


(defun bar () 
  (foo) 
  (let ((*x* 20)) (foo)) 
  (foo)) 

CL-USER: (bar) 
X: 10 
X: 20 
X: 10 
NIL

Definition:
A lexical variable is a variable that can only be referenced at the textual location of the code that creates it.

Everything starts from LET (a.k.a binding form). Here is the LET definition:


(let (variable*) 
  body-form*)

where each variable is a variable initialization form. When the LET form is evaluated, all the initial value forms are first evaluated. Then new bindings are created and initialized to the appropriate initial values before the body forms are executed. Within the body of the LET, the variable names refer to the newly created bindings. After the LET, the names refer to whatever, if anything, they referred to before(out of local scope) the LET. What happend when we use this variable in inner defined function?

What is more interesting is that, due to the ability to return functions as values, the local variable has a life span longer than the expression defining it. Consider the following example:


CL-USER: (setf inc (let ((counter 0)) 
                      #'(lambda () 
                          (incf counter))))
inc
CL-USER: (funcall inc)
1
CL-USER: (funcall inc)
2
CL-USER: (funcall inc)
3


                                      +---------------------+
                                      |                     |
                    +-------- lambda function --------+     |
                    |    func. enviroment             |     |use
               ref. |               ===========       |     |
INC --------------> |               | counter |<------|---- +
                    |               ===========       |
                    +---------------------------------+

counter has nice "secret" live inside lambda function.
We assign a value to the global variable inc. That value is obtained by first defining local variable counter using LET, and then within the lexical scope of the local variable, a lambda expression is evaluated, thereby creating an annonymous function, which is returned as a value to be assigned to inc. The most interesting part is in the body of that lambda expression - it increments the value of the local variable counter! When the lambda expression is returned, the local variable persists, and is accessible only through the annonymous function.

The thing to remember from this example is that, in other kinds of languages like Java and C/C++ the lexical scope of a local variable somehow coincide with its life span. After executation passes beyond the boundary of a lexical scope, all the local variables defined within it cease to exist. This is not true in languages supporting that return functions as values. Lexical scoping is enforced strictly, and therefore the only place from which you can alter the value of counter is within the lexical scope of the variable - the lambda expression. As a result, the counter state is effectively encapsulated. The only way to modify it is by going through the annonymous function stored in inc. The technical term to refer to this thing that is stored in inc, this thing that at the same time captures both the definition of a function and the variables referenced within the function body is called a function closure.

NOTE: If you keep in mind that "#'" means roughly "allocate (in the heap)
a closure for the following LAMBDA expression".

What if we want to define multiple interface functions for the encapsulated counter? Simple, just return all of them:


CL-USER: (setf list-of-funcs (let ((counter 0))
                                (list #'(lambda ()
                                          (incf counter))
                                      #'(lambda ()
                                          (setf counter 0)))))
CL-USER: (setf inc (first list-of-funcs))
CL-USER: (setf reset (second list-of-funcs))
CL-USER: (funcall inc)
1
CL-USER: (funcall inc)
2
CL-USER: (funcall inc)
3
CL-USER: (funcall reset)
0
CL-USER: (funcall inc)
1

NIRVANA!

CV

2006-10-04T11:16:00.023+03:00

PERSONAL INFO
=========================================================

Name: Zlatozar Zhelyazkov
Birth Date: 05 May 1973
Address: Sofia, Nadejda 2
Family Status: Married

Email: zlatozar@gmail.com

EDUCATION
=========================================================
1991 – 1996
Technical University of Sofia
Specialty: Computer Science

Thesis in Cryptographic Algorithms.

EXPIRIENCE
=========================================================

06/1998 – 03/2001
BG Contact (http://www.bg-contact.com)

Position: Head of Toshiba Technical Service (Office Plovdiv)
Service Parts Logistics
Customer support
Toshiba products maintenance
New Toshiba products presentation

3/2001 – 9/2001
ProSyst, Sofia

Position: Junior Java Developer

Project: ProSyst Application Server

10/2001 – 05/2005
IFAO Group, Bulgaria (www.ifao.net)

Position: Java Developer
CVS and Subversion support
Versions building
Product installation on servers
Writing JSP and XSL files for presentation layer
Business logic implementation
Writing Booking Business logic

Project: Cytric (www.cytric.net)
cytric provides an instant overview of the locations of all a company´s travelers. Its Software-as-a-Service (SaaS) principle. Other highlights include optimized hotel search, integration of new airline programs and the import of offline bookings into cytric Enterprise Reporting.

05/2005 – 08/2008
Industria, Bulgaria (www.industria.com)

Position: Senior Java Developer
Perforce, Subversion support
Linux servers maintainer
Java code review
Writing Java server side
Writing UI (JavaScript part)

Project: IMS Universal
Industria IMS Universal is based on TM Forum's NGOSS architecture and an open standards compliant workflow-processing engine. The system's business process-driven foundation provides telecom operators and service providers with a unified view of their converged network delivery channels, independent of the underpinning technologies.

Project: Zignal IPTV
Zignal suite of IPTV software solutions and devices is specifically designed for use by broadband network operators, multi-play service providers, hoteliers and other large-scale operators.

09/2008 – 03/2010
Xentio, Bulgaria (www.xentio.com)

Position: Senior Java Developer
Application architecture decisions
Choose suitable frameworks and technologies
Write application critical parts
Code review

Project: MAPS for ASML company (www.asml.com)
MAPS is a tool that aids in defining and maintaining machine, test and factory constants.

04/2010 – 10/2011
Cisco, Bulgaria (www.cisco.com)

Position: Software Engeneer

Project: Cisco Web Mail

10/2011 - present
Cisco, Bulgaria (www.cisco.com)

Position: Software Engineer at Architecture Team

Project: Cisco Quad

COMPUTER SKILLS
=========================================================
Languages: Java, JavaScript, C++, Lisp, Python, Bash Shell
Systems: Windows, Linux (Debian fan), FreeBSD
Application servers: WebLogic, JBOSS
Database: Oracle, MySQL

FRAMEWORKS, TECHNOLOGIES
=========================================================
SVN, Mercurial, Git
Hibernate, iBatis
XSL, XPath, XQuery
Ant, Maven, Make/CMake
ANTLR
GWT

BRAINBENCH CERTIFICATS
=========================================================
Programming: Java-Non GUI (Master), XML, C, OO Design Patters.
Network Administration: Basic Linux Administrations.
Other: Written English

ADDITIONAL CERTIFICATS
=========================================================
Toshiba fax and copiers engineer.

ARTICLES/CODE
=========================================================
Destination FreeBSD
About Programming
My public code repository

AMAZON PROFILE
=========================================================
Amazone profile

LANGUAGES
=========================================================
English, Russian

INTERESTS
=========================================================
Football, Swimming, Boxing, Reading, Writing

Fashion Axis-Hibernate

2006-09-10T20:21:00.002+03:00

Дали ще бъдем модерни ако решим да използваме Java, Linux, JBoss, Apache Axis и Hibernate3?
Определено ДА. Наскоро ми се наложи да сглобя нещо такова за много кратко време.
Като разпитах се оказа, че това и често избирана комбинация при разработката на софтуер. Затова ще споделя моя опит и идеи.
Да се направи нещо такова:
Имаме някакъв уеб базирано приложение и когато се обърнем към него през уеб сървисите, които той предлага, взема нещо от базата дани и ни врща резултат.
Ама и аз какво описание дадох. Много общо го формулирах ама който се интересува ще му стане ясно за какво идва реч.

Ето какви мисли ме налегнаха, когато видях задачата и как си отговорих на тях.

Каква линукс дистрибуция да използвам?
Как да напрявя така че да променям приложението най-безболезнено?
Дали ще мога да генерирам част от кода?
и още един допълнителен: Какво ще ям довечера?

Първия въпрос го отсях веднага щом ми казаха, че имам пълна свобода за хостващата система.
Казах си, да бъде Debian. При Дебиан нещата с инсталирането на java са специфични. Няма .deb пакети затова човек сам трябва да си го направи. Ето как:

1. Като root си инсталирам нещата, които ми трябват за създаването на java пакета:
# apt-get install java-package

2. Важно! "fakeroot" се използва за създаването на .deb
# apt-get install fakeroot

3. Вече не съм root.

4. Изтеглям <SUN JAVA SDK FILENAME>.bin от сайта на Sun .
Изтегляния файл го записвам в една temp директория.

5. Смело стартирам 
$ fakeroot make-jpkg <SUN JAVA SDK FILENAME>.bin

6. Инсталирам Java .deb Packagе вече като root:
# dpkg -i <GENERATED DEB PACKAGE FILENAME>.deb

7. Проверявам какво съм направил и дали рабои
$ java -version

5. Setup на JAVA_HOME, CLASSPATH и JBOSS_HOME в /etc/profile

export JAVA_HOME=/usr/lib/j2sdk1.5-sun/
export CLASSPATH=.

export JBOSS_HOME=/opt/jboss-4.0.4.GA

Подготвям се старателно и за JBOSS. Директорията /opt съм я отделил предвидливо в отделен patition. Създавам и user - jboss.
Логвам се като jboss свалям последната версия на сървъра и разархивирам в /opt. Да обаче като гледам как се пуска си викам, абе какво ще стане ако сървъра се рестартира? Някои трябва да го стартира автоматично всеки път. За production сървъра ще е добре jboss да се пуска като демон. Ето как става и това:

#! /bin/sh
# /etc/init.d/jboss
#

# NOTE: Points JBoss installation dir
JBOSS=/opt/jboss-4.0.4.GA

start(){
echo "Starting jboss..."
su -l jboss -c "$JBOSS/bin/run.sh > /dev/null 2> /dev/null &"
}

stop(){
echo "Stopping jboss..."
su -l jboss -c "$JBOSS/bin/shutdown.sh -S &"
}

restart(){
stop
sleep 60
# protect against any services that can't stop before we restart
# (warning this kills all Java instances running as 'jboss' user)
su -l jboss -c 'killall java'
start
}

case "$1" in
start)
start
;;
stop)
stop
;;
restart)
restart
;;
*)
echo "Usage: /etc/init.d/jboss {start|stop|restart}"
exit 1
esac

exit 0

В Дебиан, за да сложиш една програма като демон съпките са следните:

# инсталираме
Write this file as /etc/init.d/jboss
chmod 755 /etc/init.d/jboss
update-rc.d jboss defaults

# ако искаме да го разкараме
update-rc.d -f jboss remove

Имам си средата за исталация на приложението, време е да се заема със структурата на проекта. Това е и отговора на моя втори въпрос.
Искам всяко нещо да си знае мястото и ant скрипта да ми е максимално упростен. Да знам къде се намират генерираните файлове и къде е бизнес логиката. Мислих, мислих и ето какво измислих:

bin - тук се намират всички компилирани класове. 
Запомнете, при компилация всички конфигорационни файлове трябва да се копират
тук(всичко от conf directory)!
conf - конфигорационни файлове
data (dbschema.sql)- sql който ще се генерира
lib - всички нужни директории
src (com.zlatozar.persistence, com.zlatozar.persistence.base, com.zlatozar.soap, com.zlatozar.common)- всички сорсове
test (com.zlatozar...) - всички тестове. Запомнете, че src и test трябва да имат еднаква структура
webcontent (html, jsp) - нещата за нашия сайт
WEB-INF (web.xml, server-config.wsdd)- нужните конфигурации за сайта

При тази схема на проекта много лесно мога да генерирам нужния ми war файл и да пускам всички тестове. Идва най-интересната част за мен, настройката на Apache Axis. Нека първо да погледнем катинката и после е лесно - разказ по картинка.

Какви са минималните усилия за направата на Web Services(WS)? Пиша интерфейса, който искам да се вижда "навън" и пиша клас, които го имплементира всичко друго е Axis гимнастика. Давам пример:

package com.zlatozar.soap;
public interface SaySomething extends java.rmi.Remote {

public String sayHello(String name) throws java.rmi.RemoteException;

public String sayGoodbye() throws java.rmi.RemoteException;

public String writeSometingToDB(String id, String something)  throws java.rmi.RemoteException;

}

ето и имплементацията:

package com.zlatozar.soap;

import java.rmi.RemoteException;
import com.zlatozar.persistence.QueryManager;

public class SaysomethingSoapBindingImpl implements SaySomething {

public String sayHello(String name) throws RemoteException {
return "hello " + name + " !";
}

public String sayGoodbye() throws RemoteException {
return "goodbye my master !";
}

public String writeSomethingToDB(String id, String something)
throws RemoteException {

Something ft = new SomethingBase(id, something);
QueryManager.saveTicketToDB(ft);

return "Done. Persistance is cool. Bye.";
}

// Utilties methods
}

Обаче тук има една важна особенност: пише се SaysomethingSoapBindingImpl, а не SaySomethingSoapBindingImpl. Гледаме картинката. От тези два класа искаме да получим всичко за "axis deployment"(server side). Тук е и тънката хватка. От тези два класа генерирам .wsdl файла после от него нещата които са ми необходими - SaysomethingSoapBindingSkeleton и server-config.wsdd. Вижте и ant scrip-a ми:

<!-- ================================ -->
<!--       Axis tools definiion       -->
<!-- ================================ -->

<taskdef name="axis-java2wsdl" classname="org.apache.axis.tools.ant.wsdl.Java2WsdlAntTask">
<classpath refid="compile.classpath" />
</taskdef>

<taskdef name="axis-wsdl2java" classname="org.apache.axis.tools.ant.wsdl.Wsdl2javaAntTask">
<classpath refid="compile.classpath" />
</taskdef>

<!-- ================================ -->
<!--       Axis code generation       -->
<!-- ================================ -->

<target name="export-wsdl" depends="prepare">

<axis-java2wsdl
classname="com.zlatozar.soap.SaySomething" 
style="rpc"
classpathref="compile.classpath"
namespace="urn:soap.zlatozar.com" 
location="http://${server.name}:8080/${project.distname}/soap/${project.distname}" 
output="${basedir}\generated\${project.distname}.wsdl">
</axis-java2wsdl >

</target>

<target name="export-java" depends="export-wsdl">

<axis-wsdl2java 
output="${basedir}\generated" 
serverside="true" 
skeletondeploy="true" testcase="true"
url="${basedir}\generated\${project.distname}.wsdl" 
verbose="true" 
debug="true">
</axis-wsdl2java>

<java 
classname="org.apache.axis.utils.Admin" 
fork="true" 
failonerror="true" 
classpathref="compile.classpath"
dir="${basedir}\WEB-INF\">
<arg value="server" />
<arg file="${basedir}\generated\com\zlatozar\soap\deploy.wsdd" />
</java>

<!-- copy the files we need to the src/com/zlatozar/soap dir -->
<copy todir="src/com/zlatozar/soap" includeEmptyDirs="no">
<fileset dir="generated/com/zlatozar/soap">
<patternset>
<include name="*SoapBindingSkeleton.java" />
</patternset>
</fileset>
</copy>

<!-- copy the wsdd to WEB-INF/server-config.wsdd -->
<copy file="generated/com/zlatozar/soap/deploy.wsdd" 
tofile="WEB-INF/server-config.wsdd" />

<!-- copy generated WSDL file -->
<copy file="generated/${project.distname}.wsdl" 
todir="." />
</target>

Такааа, да поясним. Създавам директория generated, която след това мога да изтрия лесно. Генерирам wsdl файла и го използвам за генерацията на SaysomethingSoapBindingSkeleton. В soap пакета трябва да имам генериран SaysomethingSoapBindingSkeleton.java, а в WEB-INF server-config.wsdd. В писането на build.xml обърнете внимание на namespace="urn:soap.zlatozar.com" - името на пакета ама в обратен ред и прехвърлянето на generated/com/zlatozar/soap/deploy.wsdd в WEB-INF/server-config.wsdd.
До тук бяхме с Axis. Да се заемем с конфигурирането на Hibernate3.

Само да кажа, че бях доста затруднен, не в самото конфигуриране а да измисля "доброто конфигуриране".
Тъй като това беше първия ми сблъсък с Hibernate3 исках да намерея бърз начин да науча основните стъпки.

От къде да прочета нещо?

Разберах как се "мапват" класове и таблици
По advanced неща

Как да генерирам java класовете от .hbm.xml файловете?
За целта трябва да имам hibernate-tools.jar. Този jar е част от Hibernate-tools проекта и за да го имате трябва да свалите този
проект, който не е никак малък като обем и от там да си гепите толкова полезния tool. При мен нещата стоят ето така:

<!-- Hibernate code generation -->
<target name="hibernategen" depends="init" description="Generate what hibernate needs">

<property name="libHibernatetool" value="lib/hibernatetool" />

<path id="hibernateTool">
<pathelement location="${outputDir}" />
<fileset dir="${libHibernatetool}">
<include name="*.jar" />
</fileset>
</path>

<taskdef name="hibernate-tool" classname="org.hibernate.tool.ant.HibernateToolTask" classpathref="hibernateTool" />

<hibernate-tool>
<configuration configurationfile="${conf}/hibernate.cfg.xml" />
<hbm2ddl export="true" drop="true" create="true" format="true" outputfilename="dbschema.sql" destdir="data" />
<hbm2java destdir="${sourceDir}" />
</hibernate-tool>
</target>

След като имам нужните .hbm.xml лесно мога да получа нужните ми класове и sql-a.

Една добра идея е да отделя генерираните неща от нещата, които се променят. Какво имам в предвид. При генерацията се получават POJO обекти и нищо повече, а аз може да искам да добавя нещо повече в тези обекти, като utility методи. Как да отделя променящото се от непроменящото се? Вижте:

<hibernate-mapping package="com.zlatozar.persistence.base">
<class name="SomethingBase" table="SAYSOMETHING_T">
<meta attribute="implement-equals">true</meta>
<meta attribute="scope-field">protected</meta>

<id name="sys_oid" column="SYS_OID" type="long">
<generator class="increment" />
</id>

<property name="id" type="string" column="ID_C">
<meta attribute="use-in-equals">true</meta>
</property>

<property name="something" type="string"
column="SOMETHING_C">
<meta attribute="use-in-equals">true</meta>
</property>

</class>
</hibernate-mapping>

И така имам си com.zlatozar.persistens.base за POJO обектите - hibernate да си генира там каквото иска. Аз си имам:

public class Something extends SomthingBase

и си работя с него. А самото генериране не е сложно като видяхте. Почти свършихме само още няколко мисли за hibernate.
Остана управлението на сесиите към базата. Аз имам един Singleton клас InitSessionFactory, който отваря и затваря сесията.

public static SessionFactory getInstance() {
if ( sessionFactory == null )
initSessionFactory();

return sessionFactory;
}

a всички запитвания минават през QueryManager. Нещo такова:

public static void saveSomthing(SomethingBase aSome) {

Transaction tx = null;
Session session = InitSessionFactory.getInstance().getCurrentSession();
try {
tx = session.beginTransaction();

session.save(aSome);

tx.commit();
} catch (HibernateException e) {
log.error("Opperation will be rolled back", e);

if (tx != null && tx.isActive())
tx.rollback();
}
}

Е това е за сега. Решил съм да споделям и програмиските си главоблъскници. Meчтая си скоро да напиша същото и на Lisp...
.....
Какво ли ще вечерям все пак?

Хапещите от "Форма Д"

2006-08-21T17:14:00.002+03:00

   Не купувайте от "Форма Д"! Само това ще ви кажа. Сблъсках се с небивала простотия. Е, яд си ме е ама ще ви обясня за какво става въпрос та да се знае. Грешките на едни трябва да са поука за други.
   Започваме с малко предистория. Дамата която държи веригата от магазини(два на брой) е от Първомай(както и аз). Казва се Даниела, откъдето идва и "Д"-то в името на фирмата. Асистира сестра й. Парите не трябва да излизат от семейството - това го приемам. Майка, баща и братовчеди са наредени по веригата. Лошото е, че манталитета и облика на магазините не е претърпял развие. Остават си една семейна бакалия с жените начело. Келепира, келепира е важен.
   Тази събота отидох да си купя теракота от техния магазин на Карловско шосе в Пловдив. Леля Пенка-майката се изфука майсторски и даде отстъпка. Какво си купих? Да направим сметката.

Fenix Crema - 18.10лв на квадрат
Nature Beige - 18.10лв на квадрат

Общо платих: 887лв. Цената, която платих не е достатъчна за да включва транспорт (е не можели да запалят буса за такова количество) затова добавям и 4 курса до Пловдив - 40лв. Стана 927лв. Щото имат и само един работник в склада аз и брат ми помагаме активно в товаренето, от един град сме няма начин. Сега правим и проверка в Интернет. Пускам в Google: Ceramic Floor tiles price. E, видяхте ли? Цените са около 4 евро да удвоим цената за доставката и получаваме 8 евро. Значи аз съм си платил и та предплатил. Макар че ми е дадена и отстъпка иначе са по 21.30лв. Нормално, плащам много очаквам и много. Келепир, келепир.
   Добрите момченца отиват и да помагат. Товара започва...

"Аз на СОТ момче не вярвам, всички са маскари" - разсъждава чичо Наско - бащата.
"Я да си имам аз в склада и една каракачанка вързана на къс синджир. Ама лоша да трепе хора. Аз не си давам труда току така. Я да видим, кой ще краде хехехех". Да ама аз си плащам. Иначе магазина много излъскан и леля Пенка-майката много мазна. Парите бързо се вземат ама стоката се дава трудно.
   Слизаме в склада. Плочките са почти насипни. Опаковани са по 10 с много тиксо. Твърди се, че са първо качество. Товарим ли товарим в тъмния склад, добре е да имаш познати навсякъде. Никой не знае че има изненада с бели зъби скрита в ъгъла.
   Синджира се и къса, оковите падат звяра изскача. Кучето напада в гръб брат ми. Работника хвърля всичко и се качва на високо. Настава паника. Брат ми е жестоко нахапан. Подло и неочаквано, типично за фирма "Форма Д". Имаше страх и кръв. По братски винаги сме си помагали. В един момент взехме надмощие и погнахме кучето. Искахме то да умре. Ние не сме братя варвари, ние не обичаме нападения в гръб.
   Чичо Наско, чичо Наско той пари е дал и го хранил с хляб 6 месеца.
   "Въх убихте ми кучето бе, серсеми!" - крещи и тича към нас видимо вдигнал кръвното. Айде спаси кучето и си спести шамара, който му бях нарекъл - мир да има. Ама как исках да умре(кучето)!

   Искам да ви кажа нещо семейна фирма "Форма Д". Вие сте лъскави и кухи! Спрете с келепира и се докажете с честност и обноски. Вие сте търговци не си мислете, че хора като мен и брат ми ви крадат. Спрете да се подмазвате това не ви прави по-добри търговци. Палете буса и угаждайте на клиентите. Не лъжете. Назначете способни хора, а не комшията от Първомай. И не на последно място хранете кучетата си с кучешка храна, а не с хляб и помия.

Внимание в София кучетата са две!

Сбогом вие не съществувате за мен.

The force of Perforce

2006-06-29T22:42:00.001+03:00

INTRO: Kick start

I'm a new colleague and I do not know how to start with Perforce. Can you explain me just the basics steps?
* Install Perforce
* Second you have to setup your client. Client in Perforce world is your workstatation, your workspase.
--- Open P4V this is a GUI for Perforce. Then Connections -> Open New Connection
Now you have to fill fields. Here is some terms:

Client:

The client name. The name of your workspace.

Owner:

The user who created this client.

Root:

The root directory of the client file workspace, under which all client files will be placed. Here is mine:

C:\src\mainline

Options:

Just use default...

View:

A mapping from the files in the depot to files in the client workspace.
A new view takes effect on the next 'p4 sync'.
See view(mapping) example:

//depot/mainline/... //ZLATOZAR/...

So //depot/mainline/... will be mapped to my root.
--- Get things from depot. Depot is the repository. Type in workspace(root) command prompt:

p4 sync

* Before you start change file you have to declare that you want to edit it. Weird indeed but don't forget it.
All other knows that you are going to change this file. Your file is in changelist.

p4 edit //depot/mainline/Project1/MyFile.cs

* When you finish submit your changelist

p4 submit

or file by file

p4 submit TelephoneComponentHandler.cs

That is. Now more details.

PART ONE: The depot

1. Filespec Syntax
Perforce provides its own uniform syntax for referring to workspace and depot contents. This syntax is known as a file specifier, or "filespec."
Its converts filespecs to native file references for local operations. Depots, where Perforce keeps master file content, and workspaces, where users work on files, are hierarchical structures of directories and files.

A filespec uses "//" to indicate the root of the hierarchy, and "/" as a directory path and file name separator.
For example:

//depot/mainline/Project1/MyNewFile.cs

IMPORTANT !
File names are case insensitive or case sensitive it depends from instalation.
Just check it and remeber.

//depot/mainline/project1/mynewfile.cs

is the same? And also spaces in filenames and pathnames have to be quoted when they are referenced in views
-- It is possible to use wild cards

//depot/mainline/Project*/ComponentHandler.cs

--- Use "dot-dot-dot"
The "..." wildcard matches filename characters at or below a directory level.

//depot/.../SomeInnerProject/...

2. File and directory revisions
IMPORTANT !
Perforce's filespecs always refer to files, not directories. In fact there are no Perforce commands that operate on directories.
Use wild cards to refer directories.
Note:
I will describe a lot of commands, but for more information use command prompt help. Just type:

p4 help

then

p4 help [some of subjects]
p4 help [command that you are interested]

Perforce stores file versions in a sequence of numbered revisions. A filespec can refer to an absolute, numbered file revision, prefixed with #.
Filespecs can also refer to dates and labels, prefixed with @. And also label can be used to refer to file revisions to which it has been applied.
Examples:
--- displays all files in Project1

p4 files //depot/mainline/Project1/*
............
//depot/mainline/Project1/MyFile.cs#15 - edit change 5401 (text)
............

--- display revisions of files for a specific version

p4 files //depot/mainline/Project1/*#15

--- display files using date and first letter of the file name

p4 files //depot/mainline/Project1/M*@5/16/2006

3. Changes and changelists
Perforce uses changelists to track changes submitted to the depot. Every changelist commit number is a snapshot of the depot (It is similar to tags in CVS). Versioning numbers are global
See my ASCII graphic:


Date:           05/05/2006  07/05/2006      23/05/2006
|          |               |
|    |        |            |    |
file1 -----------| #1 |--------|------------| #2 |------
|    |        |            |    |
|          |               |
|        |    |            |
file2 -----------------------| #1 |----------------------
|        |    |            |         
|          |               |
|    |        |               |
file3 -----------| #1 |---------------------------------
|    |        |               |
|          |               |
Changelist trak:   @102       @109             @114

4. Browsing the file tree
See examples:
--- to list all depots

p4 depots

(or p4 dirs "//*")
--- to list all dirs and subdirs

p4 dirs "//depot/*"

--- see file changes history

p4 changes -m5 //depot/mainline/Project1/TheFile.cs

Note:: The -m5 flag restricts the output to the five most recent changes. Each change is identified with a changelist number and the first 30-odd characters of a description. If you want to see entire descriptions, use changes -l.
--- what is on the default change list when I commit my files

p4 describe -s 5401

--- shows file revision numbers and the action (add, delete, etc.) that took place at each revision

p4 filelog //depot/mainline/Project1/TheHandler.cs

--- to see all changes and changelist

p4 annotate -c //depot/mainline/Project1/TheHandler.cs | more

(P4V's Time-lapse View is generated from the output of the annotate command.)
--- if you want to take a file(some revision) and pass it to another file

p4 print -q //depot/mainline/Project1/TheHandler.cs > newTCH.txt

--- compare revisions

p4 diff2 //depot/mainline/Project1/TheHandler.cs#14
//depot/mainline/IProject1/TheHandler.cs#15 | more

(p4 diff [old revision] [new revision])
In P4V the Tools -> Diff files command can be used to diff any two files or revisions. It shows only different lines! Eclipse diff wins...
The same command can be used to compare any two revisions of a directory. That is realy impressive. Keep in mind that Perforce can compare and merge onky text files.
--- discover file types
See:

p4 help filetypes

+x
The workspace file is executable.
+w
The file is writable as soon as it's copied to the workspace. (Normally you have to open files to make them writable.)
+k
RCS-like keywords in the file are expanded when the file is copied to the workspace.
+l
The file is exclusively locked when opened so that only one person can have it open at a time.
+m
The file's modification time is propagated with the file so that it shows up in the timestamp of synchronized copies.
+S
Only one revision (the head revision) of the file is stored in the depot.
(This is useful for files generated and submitted by nightly builds, for example.)

Commbinations are also posible:

binary+lw

etc.

PART TWO: Files, workspace and change list

1. Creating workspace. Working with local files
The first thing you do before you can work on files is define a client workspace for yourself. A client workspace specification, or client spec, tells Perforce where in your local filesystem you want your workspace to be rooted. It has a view that defines the areas of the depot you want access to, and maps them to directories beneath the workspace root.
--- set up new
Note:: If P4CLIENT is not set, the name of your host machine will be used as the current workspace name.

For example, say you want to configure a workspace named Zlatozar-BG. First, you open up a client form in default editor:

p4 client Zlatozar-BG

An easy way: In P4V with the Connection -> Open Connection. Fill fields.
--- synchronyze workspace. Current dir.

p4 sync

--- get only one part

p4 sync //depot/mainline/Project1/

--- view all changes that are made after my commit

p4 changes "@>5401"

How to rewrite all my current changes?
* Check all files that you have changed

p4 diff -sa

* Reverting files is how you discard changes you've made to local files, rather than submitting them

p4 revert //depot/[path to the file]

How to restore localy removed files?
* Find them

p4 diff -sd

* List the files Perforce thinks you have with the have command

p4 have //.../Project1/...

* Restore(force) them

p4 sync -f //.../Project1/...

Note:: Workspace files are under your control and there's nothing to stop you or the programs you run from erasing files Perforce put there. But because Perforce thinks you have them already, you won't be able to replace them with a simple sync. So force it.
2. Working with local files
When you synchronize your workspace with depot files, Perforce normally puts read-only files on your local disk. To make files writable, you have to open them. You also have to open files you plan to add to or delete from the depot.Remember, in Perforce, an "open file" is a file you plan to submit to the depot. Don't confuse Perforce's meaning of "open" with the idea of opening files in an application.
--- open for edit

p4 edit //depot/mainline/Project1/TheHandler.cs

Now file is writable and in changelist. Team knows that you are working on that file if they type:

p4 opened -a //.../Project1/...

How many programers can work(open) on the same file?
All programers but first commiter wins. Rest of them have to resolve possible conflicts.
When you open file Perforce worns you thst another programmer works on it. Somthing like:

... - also opened by gosho@...

(Read more about p4 resolve....it is not so easy.)
--- add files to depot
There is no need to open file to add it. You can open files only if they're in your workspace view.

p4 add //.../Project1/SofiaHandler.cs
p4 submit

--- delete files from depot

p4 delete //.../Project1/StrangeHandler.cs
p4 submit

As you open files, they are associated with a pending changelist. Your local changes don't affect the depot until you submit your files. What you submit to the depot is not individual files, really, but the entire pending changelist.
IMOPRTANT !
Remove all uchenged files first or commit files one by one

p4 revert -a
p4 submit

This is a weak point realy... be careful. It is posible to commit unchanged files. Realy realy weak point. Sorry. You can use this script:

# throw away (opened but) unchanged files
# (in Perforce it's a little bit too easy
# to checkin unchanged files)

p4 diff -sr | p4 -x - revert

Hi. I'm very creative programmer and I work on many differen tasks. How can I separate my works?
* The answear is - create different changelist for diffrent tasks an gave them proper names.

p4 change

This command brings up a spec form, just like submit. The form will list all the files opened in your default changelist. Simply fill in a description and save the form to move files to the new changelist.
* Open for edit in the right changelist

p4 edit -c dt-456

* Submit right changelist (eg. "dt-456")

p4 submit -c dt-456

* Empty pending changelists can be deleted

p4 change -d dt-456

PART THREE: Misc

1. Snapshots
Every time a user submits files to Perforce, a snapshot of the depot is created automatically. The changelist number created at submit time is effectively a global revision number. It can be use to reference any file or set of files in the depot snapshot. Don't forget that.
For example when submit change list:

p4 submit
..........
Change 5401 submitted.

As you see the submit number is global. So you can refer it. If you want to take spesific change list (actually this is a snapshot):

p4 sync //depot/mainline/...@5401

p4 diff2 -q //depot/mainline/...@5400 //depot/mainline/...@5401

(and I found out all my changes)
or just use P4V's Folder Diff tool to compare snapshots...
2. Labels
In Perforce, as in many SCM systems, you can tag files with a label. To give names to snapshots. A label lets you use memorable names like REL2.0.1 to refer to specific configurations of file revisions.
--- see all labels maded from karl

p4 labels |grep alex

--- applying a label to files

p4 tag -l rel-2.0.1 //depot/mainline/...

--- referring label

p4 sync @rel-2.0.1

--- all files in label

p4 files @rel-2.0.1

3. Jobs
A job is an object in the Perforce database that can be used to tie development activity to external information. Jobs can be used for anything—requirements, project plans, to-do lists — but their most common use is for defect tracking.

PART FOUR: Resolving and merging (advanced level)

PART FIVE: Branching and merging (black belts)

To be continued...

Исландия моя любов

2006-05-07T21:54:00.001+03:00

Струва си да се разгледа тази страна. Ето и още снимки тук

How to solve it?

2006-04-02T18:27:00.000+03:00

(by G. Polya)

Getting Acquainted
Where should I start? Start from the statement of the problem.

What can I do? Visualize the problem as a whole as clear and as vividly as you can. Do not concern yourself with details for the moment.

What can I gain by doing so? You should understand the problem, familiarize yourself with it, impress its purpose on your mind. The attention bestowed on the problem may also stimulate your memory and prepare for the recollection of relevent points.

Working for Better Understanding
(Questions are: What is the unknown? What are the data? What is the condition?)

Where should I start? Start again from the statement of the problem. Start when this statement is so clear to you and so well impressed on your mind that you may lose sight of it for a while without fear of losing it altogether.

What can I do? Isolete principal parts of your problem. The hypothesis and the conclusion are the principal parts of a "problem to prove"; the unknown, the data, and the conditions are the principal parts of a "problem to find." Go through the principal parts of your problem, consider them one by one, consider them in turn, consider them in various combinations, relating eache detail to other details and each to the whole of the problem.

What can gain by doing so? You should prepare and clarify details which are likely to play role afterwards.

Drow a figure. Introduce suitable notation. Separate the parts of the condition. Can you write them down?

Hunting for the Helpful Idea
(Questions are: Have you seen it before? Do you know a related problem? Here is a problem related to yours and solved before. Could you use it?)

Where should I start? Start from the consideration of the principals parts of your problem. Start when these principal parts are distinctly arranged and clearly conceived, thanks to your previous work, and when your memory seems responsive.

What can I do? Concider your problem from various sides and seek contacts with your formery acqired knowledge.
Consider your problem from various sides. Emphasize different different parts, examine different details, examine the same details repeatedly but in different ways, combine the details differently, approach them from different sides. Try to see some new meaning in each detail, some new interpretation of the whole.
Seek contacts with your formery acquired knowledge. Try to think of what helped you in similar situations in the past. Try to recognize something familiar in what you examine, try to perceive somthing useful in what you recognize.

What could I perceive? A helpful idea, perhaps a decisive idea that shows you at a glance the way to the vary end.

How can the idea could be helpful? It shows you the whole of the way or a part of the way; it suggest to you more or less distinctly how can proceed. Ideas are more or less distinctly how you can proceed. Ideas are more or less complete. You are lucky if you have any idea at all.

What can I do with an incomplete idea? You sould consider it. If it looks advantageous you sould concider it longer. If it looks reliable you should ascertain how far it leads you, and reconsinder the situation. The situation has changed, thanks to your helpful idea. Consider the new situation from various sides and seek contacts with your formery acquired knowledge.

What can I gain by doing so again? You may be lucky and have anoder idea. Perhaps your next idea will lead you to the solution right away. Perhaps you need a few more helpful ideas after the next. Perheps you will be more led astray by some of yours ideas. Neverthe less you should be grateful for all new ideas, also for the lesser ones, also for the hazy ones, also for the supplementary ideas adding some precision to a hazy one, or attempting the correction of a less fortunate one. Even if you do not have any appreciable new ideas for a while you should be grateful if your conception of the problem becomes more complete or more coherent, more homogeneous or better balanced.

Carrying Out the Plan
(Questions are: Carrying out your plan of the solution, check each step. Can you see clearly that the step is correct? Can you prove thet it is correct?)

Where should I start? Start from lucky idea that led you to the solution. Start when you feel sure of your grasp of the main connection and you feel confident that you can supplay the minor details that may be wanting.

What can I do? Make your grasp quite secure. Carry through in detail all the algebriac or geometric operations which you have recognized previously as feasible. Convince yourself of thr correctnrss of each step by formal reasoning, or by intuitive insight, or both ways if you can. If your problem is very complex you may distinguish "great" steps and "small" steps, each great step being composed of several small ones. Check first the great steps, and get down to the smaller ones afterwards.

What can I gain by doing so? A presentation of the solution each step of which is correct beyond doubt.

Where should I start? From the solution, complete and correct in each detail.

What can I do? Consider the solution from various sides and seek contacts with your forery acquired knowlidge.
Consider the details of the solution and try to make them as simple as you can; survey more extensive parts of the solution and try to make them shorter; try to see the whole solution at a glance. Try to modify to their advantage smaller or larger parts of the solution, try to improve the whole solution, to make it intuitive, to fit it into formery acquired knowledge as naturally as possible. Scrutinize the method that led you to the solution, try to see its points, and try to make use of it for other problems. Scrutinize the result and try to make use of it for other problems.

What can I gain by doing so? You may find a new and better solution, you may discover new and interesting facts. In any case, if you get into the habit of sureveying and scrutinizing your solutions in this way, you will acquire some knowledge well orderedand ready to use, and you will develop your ability of solving problems.

Nice illustration could be found here

Next step is, How to work?

These days our lives are busier than ever. We work more than ever. We are more stressed and exhausted than ever before. And yet we get less done and are not as happy.

It doesn’t have to be that way.

The problem is that we are overloaded with information and tasks, and we try to get everything done instead of just the most essential things. Solution: focus on only the essential, eliminate the rest, and allow yourself to get into that beautiful state known as “flow”.

And although it can be hard to give up all the busy-ness that we’ve grown accustomed to, the change will have tremendous benefits on our sanity, our stress levels, our happiness, and yes, our productivity.

Here are 10 simple ways to be more productive with less effort:

1. Clear your head. It’s impossible to gain perspective, and to know what is truly essential, if we are in the middle of an information stream. Take an hour, or half a day if possible, to shut off the information flow, and to get a larger view of your life and your job. The time you take off will be well worth it. Tell everyone that you are unavailable, shut off all communications, shut yourself in somewhere private, and take some time to think about what is important. What do you want? Where are you going? What will it take to get there? Another good way to clear your head, which is necessary for focus, is to write down everything that you need to do, all your tasks and projects and ideas. Dump the contents of your mind on paper, and then stop thinking about them for a little while.

2. Focus on the essential tasks. Once you’ve gotten your head cleared, you need to figure out what tasks are most essential. Ask yourself this magic question: “What task can you do that will get you the most return on your time?” Figure out the project that will get you the most recognition, win you awards, or get you the most business. Something that will pay off big. Not something you’ll forget about in a week, but something that others will remember you by. This is an essential task. Make a list of these types of tasks — they’re your most important things to do this week.

3. Eliminate the rest. Now look at your overall list. What’s on there that’s not essential? Can you just drop them from your schedule? Or delegate them to someone else? If not, put them on a “waiting list”. Then, as you focus on your essential tasks, check back on this waiting list every now and then. Sometimes you’ll realize that the less essential tasks weren’t really necessary at all.

4. Do essential tasks first. If you’ve got a list of things to do today, and one or two of them are truly essential, do those items first thing in the morning. Don’t wait until later in the day, because they’ll get pushed back as other urgent stuff comes up. Get them out of the way, and your productivity will truly soar.

5. Eliminate distractions. You can put essential stuff on your list all year long, but if you are constantly interrupted by email notifications, IM, cell phones, your RSS reader, gadgets and widgets, social media, forums and the like, you’ll never be productive. Turn these things off, disconnect yourself from the Internet if possible, clear your desk of all papers, clear your walls and surrounding areas, and allow yourself to truly focus.

6. Use simple tools. Don’t fidget with a bunch of gadgets or the latest and coolest applications. Find a simple notebook for writing things down, a simple to-do list (no frills) and the simplest application possible for doing your work. Then forget about the tools and think only of the task at hand. If you’re too worried about the tools, you’re not actually doing anything.

7. Do one thing at a time. Multi-tasking is a waste of time. You can’t get things done with a million things going on at once, pulling for your attention. Focus on the essential task in front of you, to the exclusion of all else, and you are much more likely to get it completed, in less time, with less effort.

8. Find quiet. In addition to a quiet working environment, you need time every day that you can call your own, where you don’t have to do work. This could be through reading, taking a bath, walking in nature, going swimming at the beach, going jogging, meditating. Not reading your feeds. Get away from the information overload and find that peace that will allow you to truly focus when you do work, and to review your day in your mind, and to get the perspective to see what is essential.

9. Make the most of your work. It’s one thing to write something great, or to create something fantastic. But it’s entirely another thing to make that great thing explode, to get you attention, to earn the recognition you deserve — which will lead to more business or more opportunities. Once you’ve created the Next Great Thing, promote it, show it to others, find a way to have it carry you as far as it can take you. Don’t just create something and move on to the next thing. Use your energy and talents to their fullest extent.

10. Simplify some more. Once you’ve simplified down to the essential, and eliminated distractions, you should become productive. But distractions and the unnecessary have a way of creeping back in and accumulating. Every now and then, take a look at what you’re doing, at the information coming into your life, at how you spend your time and the tools you use. Then simplify some more.

Polished FreeBSD box

2006-03-16T16:15:00.000+02:00

И сега, когато си имаме Super FreeBSD Box е време за някой хватки, които ще ни помогнат в нашето ежедневие.

1. Клавиатурната подредба, малко е кофти. Insert, Home, End... не работят. So what?

Сложете в .inputrc.


set meta-flag on
set output-meta on
set convert-meta off

"\e[1~": beginning-of-line
"\e[2~": yank
"\e[3~": delete-char
"\e[4~": end-of-line
"\e[C": forward-char
"\e[D": backward-char
"\e[A": previous-history
"\e[B": next-history
"\C-?": delete-char
"\C-H": backward-delete-char
"\e[1~": beginning-of-line
"\e[4~": end-of-line

2. Искате ви се да имате готин emacs:

Сложете в .emacs:


;; Syntax highlight
(global-font-lock-mode t)

;; Higlight the marked region (C-SPC)
(transient-mark-mode t)


;; Some useful key bindings
(global-set-key [home] 'beginning-of-line)
(global-set-key [end] 'end-of-line)

;; Display matters
(display-time)

(setq blink-cursor nil)
(setq column-number-mode t)
(setq visible-bell t)
(setq tab-width 4)

;; wheel mouse
(global-set-key [mouse-4] 'scroll-down)
(global-set-key [mouse-5] 'scroll-up)

3. Ама мен bash по ме кефи. OK, baby!

Инсталирате си го и направете


chsh -s /usr/local/bin/bash

4. Искам prompt-та да ми е по-така!

В .bashrc се написва:


PS1="\t \u@(\[$(tput md)\]\w\[$(tput me)\])"
case `id -u` in
        0) PS1="${PS1}# ";;
        *) PS1="${PS1}$ ";;
esac

5. Как да mount-на флопито?

Създравате директорита /fdd в root директорията. После в /etc/fstab се добавя:


/dev/fd0      /fdd            msdos   rw,noauto       0       0

и сега вече се пише само: mount /fdd

6. Как лесно да си пусна настройките на X-a?


/usr/X11R6/bin/xorgconfig -textmode

7. Как да ми проработи колелцето на мишката?

Добавете следните редове в /etc/X11/xorg.conf


Option "ZAxisMapping" "4 5"
Option "Buttons" "5"

8. Искам да си играя игрички, човече?

OK, ама нещата тук не са лесни. Трябва да се инсталира nVidia драйвера. Ето и стъпките, които трябва да се следват:

--- Редактираме /boot/loader.conf. В него добавяме:


#Nvidia driver
nvidia_load="YES"

#Nvidia's agp driver
agp_load="YES"

#Linux compatibility support
linux_load="YES"

---(optional) Ако нямате инсталирани следните приложения, направете го:


cd /usr/ports/emulators/linux_base-8 && make install clean
cd /usr/ports/x11/linux-XFree86-libs && make install clean

--- Инсталираме nVidia драйвера


cd /usr/ports/x11/nvidia-driver && make install clean
cd /usr/ports/x11/nvidia-settings && make install clean

--- (IMPORTANT) Трябва да забраним FreeBSD драйвера!
Редактираме /boot/device.hints


hint.agp.0.disabled="1"

--- Конфигурираме X server, като редактираме /etc/X11/xorg.conf


# (1) Uncomment
Load "glx"

# (2) Scroll down to the "server flags" section of the file
# and insert the line shown below
Option "NvAGP" "1"

# (3) In the part that says "Driver", replace the "nv" with "nvidia",
Driver "nvidia"

--- (EXTRAS) Maлко да засилим нещата, като добавим в /etc/sysctl.conf:


#Enable AGP Side band Addressing
hw.nvidia.registry.EnableAGPSBA=1

#Enable AGP Fast Writes
hw.nvidia.registry.EnableAGPFW=1

E това е за сега, но това е само началото...

Да лекуваш рак с витамини

2006-02-19T13:23:00.002+02:00

   Витамините винаги помагат, когато са комбинирани с надежда. Има ги в изобилие. Понякога дори вършат чудеса и извеждат душата от Долината на сенките. Помнете ми думата - помагат. Ама бил си добър. Не се отпускай, добрината не дава имунитет.
   Колкото и пари да има за раково болните, нищо не е по-добро от навремената реакция от точната диагностика. Да, морфин ще има до края на дните ти. Заменя ли това радостта при отварянето на очите рано в хладната утрин и удоволствието да съществуваш? Отговаря ли това на въпроса, защо аз?
   Тъжно е като гледаш умиращ каубой за десет секунди на големия екран. Боли го и държи дясната си ръка върху корема. Един подлец го е прострелял. Нечовешко е обаче, когато най-близкия до теб се мъчи с месеци и години улучен от съдбата. Бори се и не знае кой да обвини. Съдбата стреля на посоки, казвам ви.
   Инжекцията не е решение, тя е временна забрава. И ето тогава идват витамините. Те са бъдещето и надеждата за утрин без болка. Утрин, но без кафе, то е храна за плевела в теб. Приложи само кураж и чаша студен чай. Бори се с кошмарите и некадърността на провинциалните лекари. Движи се и упражнявай волята си. Тази рецепта няма упътване, само едно наставление - опитай се да живееш!
   Невъзможното е нищо. Аз съм до теб и държа ръката ти, татко. Ще ти давам витамините и ще си говорим за идващото лято.
"Ей Заре, покрива е за ремонт." Усмихвам се - "Разбира се че ще помагам, татко."
Добротата не е застраховка, тя е качество което ти притежаваш и затова ние те обичаме.