Complex : Part Reality and Part Imagination

Richard Resnick: Welcome to the genomic revolution

2011-09-17T19:47:00.001-07:00

Jeremy Gilley: One day of peace | Video on TED.com

2011-08-12T00:16:00.000-07:00

Jeremy Gilley: One day of peace | Video on TED.com

Steps for installing ddd on linux for beginners

2011-08-07T21:28:00.000-07:00

Download source code from ddd site and save it. It gets saved in Desktop

Move it to /usr/src

Untar it

Download source code for lesstif

Move it to /usr/src

Untar it

Go to lesstif dir

./configure

Make

Make install

Go to ddd dir

./configure

Make

Make install

Ldconfig /usr/local/lib

ddd

Some useful Linux commands I came across as a beginner and documented for future use

2011-08-07T21:26:00.000-07:00

Registering copy of red hat enterprise linux

rhn_register

To extract tar.gz file in cygwin

gunzip -d httpd-2_0_NN.tar.gz

tar xvf httpd-2_0_NN.tar

Cygwin commands

Cygcheck -s

Whereis boost

Cygpath ==> to get corresponding linux path

Cygpath --windows ==> to get corresponding windows path

SVN

svn checkout (or just co) http://xx.xx.xx.xxx/x/xx/trunk /root/xxx/

Svn status ------> to find all the modified files

svn copy http://xx.xx.xx.xxx/x/xx/trunk http://xx.xx.xx.xxx/x/xx/trunk2 -m "comment"

svn ls http://xx.xx.xx.xxx/x/xx/trunk

svn info http://xx.xx.xx.xxx/x/xx/trunk

svn diff http://foo.com/branches/stable http://foo.com/trunk

Grep commands

grep -iR "" *.* -------> find the text in all the files with ignore case and recursively in subdir

Linux machine access remotely from windows machine

Installing xRDP: http://www.fedoraforum.org/forum/showthread.php?t=193101

Commands for SSH via cygwin:

$ xwin –ac –resize &

$ DISPLAY=:0 ssh –CXYtf root@xxx.xx.xx.xxx  /usr/bin/gnome-session

To get OS configuration

uname -a

Shutdown linux box

Shutdown -h now

Reboot

Current directory

pwd

To start GUI

Startx

Tty?

To copy file remotely (secure copy = scp)

scp root@xxx.xx.xx.xx:/home/xxx/desheu1.tar.gz .

Super user

Su-

Install using super user account

Sudo Yup install xrdp

Sudo Yup install screen

To list running processes and killing one process

Ps -ef | grep "firefox"

Kill -9

To clear the terminal screen

Clear

Installing Java

Yum install java

To find where is the package installed

Type screen

Which screen

Find / screen

listing all the scsi devices on linux box
lsscsi: to list the scsi devices on the local system
>yum install lsscsi
>lsscsi
equivalent on windows is diskpart.exe with LIST DISK command

installing sg_utils
yum install sg_utils
The list of sg utils can be found at http://sg.danny.cz/sg/sg3_utils.html. You can also download the utilties on windows from this site. Utils i tried and which works on both Windows and Linux are like
sg_scan

Some commands to explore
top : similar to task manager in windows
dd: create large files
man (page 1: bash commands, page 2: system calls, page 3: CLIs etc)
ldd: list dependant modules - static list read from a dll or exe
lsmod: list loaded kernel modules
grep, e(xtended)grep and f(ast)grep : to find substrings from a file using regex
find: to find files with regex
ulimit: http://justlearningtoblog.wordpress.com/2010/07/23/enable-core-dump-files-in-fedora/
ifconfig to get the ip and mac address
strace
ptree
df -ah : to check the disk free
du -ah: to list disk usage
mount : to list all the mounted fs

Some questions to answer:
Where does the core dump go for deamons vs CLIs?
http://justlearningtoblog.wordpress.com/2010/07/23/enable-core-dump-files-in-fedora/

shared memory/mapped files/pipes on linux
system calls (fopen vs open)

How to check the list of dynamically loaded libraries in a live process? lsof -p
(
http://www.akadia.com/services/lsof_intro.html
http://www.unix.com/programming/34498-how-view-loaded-shared-libraries-running-processes-linux.html)

Some cheet sheet for commands:
http://www.pixelbeat.org/cmdline.html

Basic vi editor commands
y - copy
h j k l - arrow left, down, up, right (respectvely)
yy - copy one line
p - paste
:buffers - to list the buffers copied in clipboard
yw - copy one word
yn - copy n lines
ynw - copy n words
0 - go to the start of the line
y0 - copy from current cursor till start of line
$ - go to end of line
y$ - copy from current cursor to end of line
u - undo
dd - delete one line
dj - delete current and line below current line (remember j is the arrow down command)
guu - lowercase
gUU - uppercase

Daniel Kraft: Medicine's future? There's an app for that | Video on TED.com

2011-07-06T23:33:00.000-07:00

An interesting read:

Daniel Kraft: Medicine's future? There's an app for that | Video on TED.com

Robert Hammond: Building a park in the sky | Video on TED.com

2011-07-04T10:44:00.000-07:00

Robert Hammond: Building a park in the sky | Video on TED.com

Bill Gates on energy: Innovating to zero! | Video on TED.com

2011-07-03T12:55:00.000-07:00

Bill Gates on energy: Innovating to zero! | Video on TED.com

Canada Day - Wikipedia, the free encyclopedia

2011-07-01T09:49:00.000-07:00

Today is Canada Day!!!

Canada Day - Wikipedia, the free encyclopedia

Onyx Ashanti: This is beatjazz | Video on TED.com

2011-06-22T08:35:00.000-07:00

This is really creative with lots of future ...Awesome!!!

Onyx Ashanti: This is beatjazz | Video on TED.com

Amit Sood: Building a museum of museums on the web | Video on TED.com

2011-05-30T23:58:00.000-07:00

Amit Sood: Building a museum of museums on the web | Video on TED.com

"Ziya" Muley, Deepak and Naziya's Daughter, her first photos at her birth

2010-07-03T14:10:00.000-07:00

SkyScrapers Information around the world

2010-04-16T00:12:00.000-07:00

http://www.emporis.com/application/?nav=skyscrapers

http://www.skyscrapercity.com/

American Road system

2010-04-15T23:57:00.000-07:00

What is a Freeway?
http://en.wikipedia.org/wiki/Freeway

what are different Freeway interchange designs?
http://en.wikipedia.org/wiki/Interchange_(road)

How isamerican interstate highway system?
http://en.wikipedia.org/wiki/Interstate_Highway_System

Indian National Anthem

2009-12-14T23:58:00.001-08:00

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

Talks Blaise Aguera y Arcas demos Photosynth

2009-12-13T19:31:00.001-08:00

Talks Carolyn Porco flies us to Saturn

2009-12-13T19:11:00.001-08:00

Ten-Code : Interesting Codes for common phrases in voice communication, particularly by law enforcement and in Citizens' Band (CB) radio transmissions

2009-12-09T22:58:00.000-08:00

http://en.wikipedia.org/wiki/Ten-code

10-4	Affirmative Ok Understood Repeat your last message (NZ Police)

Talks Bjarke Ingels: 3 warp-speed architecture tales

2009-12-09T22:57:00.000-08:00

The Listening! (Movie)

2009-12-05T23:42:00.001-08:00

Interesting to watch!!

http://www.imdb.com/title/tt0427461/

http://en.wikipedia.org/wiki/Echelon_(signals_intelligence)

Rs 500 Note Front

2009-12-04T23:58:00.001-08:00

Rs 500 Note Back

2009-12-04T23:27:00.001-08:00

Talks Anupam Mishra: The ancient ingenuity of water harvesting

2009-12-03T10:15:00.000-08:00

Talks Evelyn Glennie shows how to listen

2009-12-02T21:50:00.001-08:00

Talks Gordon Brown on global ethic vs. national interest

2009-12-01T09:12:00.000-08:00

Talks Shashi Tharoor: Why nations should pursue "soft" power

2009-11-30T23:41:00.001-08:00

http://www.ted.com/talks/shashi_tharoor.html

Talks Hans Rosling: Asia's rise -- how and when

2009-11-29T02:24:00.000-08:00

http://www.ted.com/talks/hans_rosling_asia_s_rise_how_and_when.html

Mythology : a new look

2009-11-29T01:55:00.001-08:00

Talks Devdutt Pattanaik: East vs. West -- the myths that mystify http://www.ted.com/talks/devdutt_pattanaik.html

Beginning guitar site

2009-11-29T01:11:00.000-08:00

http://www.cyberfret.com/first-fret/index.php

Courtesy Dhwani!

Talks Pranav Mistry: The thrilling potential of SixthSense technology

2009-11-29T00:59:00.000-08:00

Talks Mallika Sarabhai: Dance to change the world

2009-11-29T00:41:00.001-08:00

Talks Steve Truglia: A leap from the edge of space

2009-10-31T20:45:00.000-07:00

Talks Tim Brown urges designers to think big

2009-10-31T19:47:00.000-07:00

Talks William Kamkwamba: How I harnessed the wind

2009-10-31T19:05:00.001-07:00

Some good DIY Project Sites

2009-10-04T10:20:00.000-07:00

http://www.diynetwork.com/

http://www.instructables.com/

http://dailydiy.com

http://scitoys.com/

http://www.devtoys.com/Projects/Science/Default.aspx

The basics of Matter and Electricity

2009-10-04T10:17:00.000-07:00

Atom

Atom is the main building block of matter like solid, liquid and gases

Molecule

Group of atoms is called molecules.

E.g.

Water has H2O meaning 2 molecules of hydrogen for every atom of Oxygen. If you break the hydrogen molecules, we get 2 atoms of hydrogen.
Gases like halium are composed of atoms as the structural unit and not molecules.

Element

An element is material composed of only one kind of atom.

Compound

A compound is material composed of more than one kind of atom.

E.g.

Some examples of elements that can be found on the periodic table are hydrogen, helium, oxygen, iron, copper, gold, aluminum, uranium.

Protons, Neutrons and Electrons

An atom is the smallest particle of any element that still retains the characteristics of that element. However, atoms consist of even smaller particles. Atoms consist of a central, dense nucleus that is surrounded by one or more lightweight negatively charged particles called electrons. The nucleus is made up of positively charged particles called protons and neutrons which are neutral. An atom is held together by forces of attraction between the electrons and the protons. The neutrons help to hold the protons together. Protons and neutrons are believed to be made up of even smaller particles called quarks.
Electrons have a negative electrostatic charge and protons have a positive electrostatic charge.
A good way to remember what charge protons have is to remember both proton and positive charge start with "P."
Like charges repel, unlike charges attract, just like with magnets.
Atoms have their electrons arranged in layers called shells.
In order to maintain electrical balance the number of electrons is equal to the number of protons in most elements.

Valence Shell, free electrons

In the copper atom's outside shell has only one electron. This represents that the copper atom has one electron that is near the outer portion of the atom. The outer shell of any atom is called the valence shell. When the valence electron in any atom gains sufficient energy from some outside force, it can break away from the parent atom and become what is called a free electron.

Electrical Current

Atoms with few electrons in their valence shell tend to have more free electrons since these valence electrons are more loosely bound to the nucleus. In some materials like copper, the electrons are so loosely held by the atom and so close to the neighboring atoms that it is difficult to determine which electron belongs to which atom. Under these conditions, the valence or free electrons tend to drift randomly from one atom to its neighboring atoms. Under normal conditions the movement of the electrons is truly random, meaning they are moving in all directions by the same amount. However, if some outside force acts upon the material, this flow of electrons can be directed through materials and this flow is called electrical current. Materials that have free electrons and allow electrical current to flow easily are called conductors. Many materials do not have any free electrons. Because of this fact, they do not tend to share their electrons very easily and do not make good conductors of electrical currents. These materials are called insulators.
Electricity is a word used to describe the directional flow of electrons between atoms.
The directional movement of electrons between atoms is called electrical current.

Amps

It is very important to have a way to measure and quantify the flow of electrical current. When current flow is controlled it can be used to do useful work. Electricity can be very dangerous and it is important to know something about it in order to work with it safely. The flow of electrons is measured in units called amperes. The term amps is often used for short. An amp is the amount of electrical current that exists when a number of electrons, having one coulomb (ku`-lum) of charge, move past a given point in one second. A coulomb is the charge carried by 6.25 x 10^18 electrons. 6.25 x 10^18 is scientific notation for 6,250,000,000,000,000,000. That is a lot of electrons moving past a given point in one second!

Ohm's Law is used to describe the mathematical relationship between voltage, current, and resistance.

OHM'S LAW

I = V/R,

I = current, V = voltage, and R = resistance

*Depending on what you are trying to solve we can rearrange it two other ways.

V = I x R

R = V/I

*All of these variations of Ohm’s Law are mathematically equal to one another

Scientific Toys, Resources and Links

2009-10-03T15:20:00.000-07:00

You will find lot of articles and books on science

A Million Books for a Billion People
http://www.arvindguptatoys.com/

Thanks to Arvind Gupta for the making this large collection available for public.

LINQ

2009-09-27T23:55:00.000-07:00

LINQ is Language Integrated Query. It is pronounced “link” and not ‘lin-queue”. It is a Microsoft .NET 3.5 component that adds native data querying capabilities to .NET languages using a syntax similar to SQL. One can do databases, XML, arrays, etc.

var results = from c in SomeCollection

where c.SomeProperty = conditionvalue

select new (c.SomeProperty, c.SomeOtherProperty);

foreach (var result in results)

XPS

2009-09-27T23:53:00.001-07:00

XPS is XML Paper Specification. It is a specification for a page description language and a fixed-document format developed by Microsoft. It is an XAML-based specification, based on a new print path and a color-managed vector-based document format which supports device independence (documents look the same and as they are intended on any device) and resolution independence. It is essentially a competitor to PDF. XPS is a part of WPF which is a part of .NET 3.0.

To save a Word or Office document as XPS do Print to File.

PDF includes dynamic capabilities not supported by the XPS format.

Is it AJAX or Atlas?

2009-09-27T23:52:00.000-07:00

Not many know that Microsoft originally invented AJAX. AJAX helps update data on a web page without a complete reload of the page.

ASP.NET AJAX was formerly known as Atlas. It is a set of extensions to ASP.NET developed by Microsoft for implementing Ajax functionality. ASP.NET AJAX was released as a standalone extension to ASP.NET in January 2007. It was subsequently included with .NET 3.5.

The key technology in ASP.NET AJAX is the XMLHttpRequest object, along with Javascript and DHTML.

XAML is EXtensible Application Markup Language (Pronounced as "zammel")

2009-09-27T23:45:00.000-07:00

It is a declarative XML-based language that defines objects and their properties in XML. You can create visible UI elements for a Windows Presentation Foundation (WPF) application in the declarative XAML markup, and then separate the UI definition from the run-time logic by using code-behind files, joined to the markup through partial class definitions. It is very intuitive for creating interfaces ranging from prototype to production especially in the sense that a web designer's exact layout can be saved in XAML and combined with the application without affecting the development process. XAML files are XML files that generally have the .xaml extension.

XAML syntax describes objects, properties and their relationships to one another. Generic XAML syntax defines the relationship between objects and children. Properties can be set as attributes or by using 'period notation' to specify the object as a property of its parent.

XAML is a part of .NET 3.0 and is used in writing WPF applications.

The Visual Studio 2008 contains "Cider", the Visual Designer for WPF. The designer's split view editor lets you see your XAML and a design view of it simultaneously, so you can see consequences of your XAML edits immediately without having to run your application.

    This is a button

Garbage Collection

2009-09-27T23:44:00.001-07:00

Garbage collection (GC) is a form of automatic memory management. The garbage collector attempts to reclaim memory used by objects that will never be accessed or mutated again by the application.

Garbage collection essentially is a 2-step process:

It determines which objects in a program will not be accessed in the future,
And then reclaims the resources used by these objects.

Automatic memory management can eliminate common problems, such as forgetting to free an object and causing a memory leak, or attempting to access memory for an object that has already been freed. It aids programmers in their efforts to make programs more stable, because it prevents several runtime errors. E.g. it prevents dangling pointer errors, where a reference to a de-allocated object is used.

In Java, the JVM takes care of releasing unused memory by keeping track of the references to allocated resources. Whenever the JVM detects that a resource is no longer referenced by a valid reference, the resource is garbage-collected.

In C#, garbage collection is handled by the CLR with similar functionality to that of the JVM. The CLR garbage collector periodically checks the memory heap for any unreferenced objects, and releases the resources held by these objects.

Reflection

2009-09-27T23:43:00.001-07:00

Reflection is a functional extension to the object-oriented programming paradigm. It includes self-examination, self-modification, and self-replication. It is commonly used by programs which require the ability to examine or modify the runtime behavior of applications. This is typically accomplished by dynamically assigning program code at runtime.

E.g. In C#, here's how you would achieve reflection:

//Without reflection

Foo foo = new Foo();

foo.Hello();

//With reflection

Type t = Assembly.GetCallingAssembly().GetType("FooNamespace.Foo");

t.InvokeMember("Hello", BindingFlags.InvokeMethod, null, Activator.CreateInstance(t), null);

Reflection is powerful, but should not be used indiscriminately. The following concerns should be kept in mind when accessing code via reflection:

Performance Overhead

Because reflection involves types that are dynamically resolved, certain optimizations cannot be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in sections of code which are called frequently in performance-sensitive applications.

Security Restrictions

Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context.

Exposure of Internals

Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods; the use of reflection can result in unexpected side-effects. This may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

P.S. Since this is an advanced feature of .Net framework, if you can use this in your application, you can call yourself an "advanced programmer"! :)

FxCop

2009-09-27T23:42:00.001-07:00

FxCop is an application that analyzes managed code assemblies (code that targets the .NET Framework CLR) and reports information about the assemblies, such as possible design, localization, performance, and security improvements.

So to say, FxCop essentially analyzes the compiled object code, and not the original source code. It uses MSIL parsing, and callgraph analysis to inspect assemblies for defects in the following areas:

Correctness
Library design
Localization
Naming conventions
Performance
Security

FxCop is intended for class library developers; however, anyone creating applications that should conform to .NET Framework best practices will benefit. FxCop is also useful as an educational tool for those who are new to the .NET Framework or are unfamiliar with the .NET Framework Design Guidelines.

FxCop is designed to be fully integrated into the software development cycle and is distributed as both a fully featured application with a GUI (FxCop.exe) for interactive work, and a command-line tool (FxCopCmd.exe) suitable for use as part of automated build processes or integrated with Microsoft Visual Studio®.NET as an external tool.

Keywords of FxCop:

Target: FxCop analyzes programming elements in managed assemblies, called targets. It provides an informational report containing messages about the targets, including suggestions on how to improve the source code used to generate them.
Rule: A rule is managed code that can analyze targets and return a message about its findings. Rule messages identify any relevant programming and design issues and, when possible, supply information on how to fix the target. FxCop represents the checks it performs during an analysis as rules.

FxCop integrates with the Visual Studio IDE to enable developers to analyze the source code at the time of coding and is a freeware downloadable from:

http://www.microsoft.com/downloads/details.aspx?familyid=3389F7E4-0E55-4A4D-BC74-4AEABB17997B&displaylang=en

internal - A keyword in C#

2009-09-27T23:41:00.001-07:00

“internal” is a new access modifier for types and type members, in addition to the existing private, public and protected. Internal types or members are accessible only within files in the same assembly. When “protected internal” is used, it keeps access limited to the current assembly or types derived from the containing class.

public class BaseClass 

{

    // Only accessible within the same assembly

    internal static int count = 0;

}

A common use of internal access is in component-based development because it enables a group of components to cooperate in a private manner without being exposed to the rest of the application code.

E.g. a framework for building graphical user interfaces could provide Control and Form classes that co-operate using members with internal access. Since these members are internal, they are not exposed to code that is using the framework.

It is an error to reference a member with internal access outside the assembly within which it was defined.

Assembly1.cs

// Compile with: /target:library

internal class BaseClass 

{

   public static int nCount = 0;

}

// Assembly2.cs

// Compile with: /reference:Assembly1.dll

class TestAccess 

{

   static void Main() 

{

      BaseClass myBase = new BaseClass();       // Error: CS0122; 'member' is inaccessible

// due to its protection level

}

}

sealed - A keyword in C#

2009-09-27T23:40:00.001-07:00

When applied to a class, the “sealed” modifier prevents other classes from inheriting from this class. Sealed classes are primarily used to prevent derivation. Because they can never be used as a base class, some run-time optimizations can make calling sealed class members slightly faster.

using System;

sealed class MyClass

{

    int x;

    int y;

}

It is an error to use the abstract modifier with a sealed class, because an abstract class must be inherited by a class that provides an implementation of the abstract methods or properties.

You can also use the “sealed” modifier on a method or property that overrides a virtual method or property in a base class. This enables you to allow classes to derive from your class and prevent them from overriding specific virtual methods or properties. This negates the virtual aspect of the member for any further derived class. This is accomplished by putting the sealed keyword before the override keyword in the class member declaration. When applied to a method or property, the sealed modifier must always be used with override.

public class D : C

{

    public sealed override void DoWork() { }

}

Structs are implicitly sealed; therefore, they cannot be inherited.

To determine whether to seal a class, method, or property, you should generally consider the following two points:

The potential benefits that deriving classes might gain through the ability to customize your class.
The potential that deriving classes could modify your classes in such a way that they would no longer work correctly or as expected.

Silverlight

2009-09-27T23:39:00.001-07:00

Microsoft Silverlight is a cross-browser, cross-platform implementation of the .NET Framework for building and delivering the next generation of media experiences and rich interactive applications (RIA) for the Web. Silverlight unifies the capabilities of the server, the Web, and the desktop, of managed code and dynamic languages, of declarative and traditional programming, and the power of Windows Presentation Foundation(WPF).

Silverlight enables you to create a state-of-the-art application that has the following features:

It runs in all popular Web browsers, including Microsoft IE, Mozilla Firefox, and Apple Safari, and on Microsoft Windows and Apple Mac OS X.
It provides a consistent experience no matter where it runs.
It is supported by a very small download that installs in seconds.
It streams video and audio. It scales video quality to everything from mobile devices to desktop browsers to 720p HDTV video modes.
It includes compelling graphics that users can manipulate drag, turn, and zoom, directly in the browser.
It reads data and updates the display, but it doesn't interrupt the user by refreshing the whole page.

Silverlight offers you the following features:

WPF and XAML: Silverlight includes Windows Presentation Foundation (WPF) technology, which greatly extends the elements in the browser for creating UI. WPF lets you create immersive graphics, animation, media, and other rich client features, extending browser-based UI beyond what is available with HTML alone. Extensible Application Markup Language (XAML) provides a declarative markup syntax for creating WPF elements. See Creating User Interfaces with Silverlight for more information.
Extensions to JavaScript: Silverlight provides extensions to the universal browser scripting language that provide powerful control over the browser UI, including the ability to work with WPF elements.
Cross-browser, cross-platform support: Silverlight runs the same on all popular browsers (on any platform). You can design and develop your application without having to worry about which browser or platform your users have.
Integration with existing applications: Silverlight integrates seamlessly with your existing JavaScript and ASP.NET AJAX code to complement functionality you have already created.
Access to the .NET Framework programming model and to associated tools: You can create Silverlight-based applications using dynamic languages such as managed JScript and IronPython as well as languages such as C# and Visual Basic. You can use development tools such as Visual Studio to create Silverlight-based applications.
LINQ: Silverlight includes language-integrated query (LINQ), which enables you to program data access using intuitive native syntax and strongly typed objects in .NET Framework languages.

If you already use ASP.NET, you can integrate Silverlight with the server and client capabilities of ASP.NET that you are familiar with. You can create server-based resources in ASP.NET and use the AJAX capabilities of ASP.NET to interact with server-based resources without interrupting the user.

params (A keyword in C#)

2009-09-27T23:38:00.001-07:00

Arrays are used to pass a variable number of parameters to a member. C# provides the "params" keyword which lets you specify a method parameter that takes an argument where the number of arguments is variable. No additional parameters are permitted after the params keyword in a method declaration, and only one params keyword is permitted in a method declaration.

E.g.

public class MyClass

{

    public static void UseVariableParameters(params int[] list)

{

        for (int i = 0; i < list.Length; i++)

{

            Console.WriteLine("{0}th parameter: {1}", i, list[i]);

}

}

}

public static void DemonstrateVariableParameters()

{

    MyClass.UseVariableParameters(1, 2, 3, 4, 5);

}

Passing variable number of parameters to methods should be used judicially. Follow guidelines given below for appropriate use of variable arrays for parameters:

Use params keyword to array parameters if you expect the end users to pass a small number of elements.
Do not use params arrays if the caller would almost always already have the input in an array.
Do not use params arrays if the array is modified by the member taking the params array parameter.
Do try to order parameters to make it possible to use the params keyword.
Consider providing special overloads and code paths for calls with a small number of arguments in extremely performance-sensitive APIs.
By following this guideline, you can avoid creating arrays when a member is called with a small number of arguments. The parameter names should be a singular form of the array parameter followed by a numeric suffix. The following code example shows a member signature that follows this guideline.

public static void WriteLine(string format, object arg0, object arg1, object arg2)

Be aware that null could be passed as a params array argument.

JSON is JavaScript Object Notation (Pronounced as Jason)

2009-09-27T23:37:00.001-07:00

JSON is a lightweight computer data interchange format. It is a text-based, human-readable format for representing simple data structures and associative arrays (called objects).

The JSON format is specified in RFC 4627 by Douglas Crockford. This format is often used for transmitting structured data over a network connection in a process called serialization. Its main application is in Ajax web application programming, where it serves as an alternative to the use of the XML format.

The following example shows the JSON representation of an object that describes a person. The object has string fields for first name and last name, contains an object representing the person's address, and contains a list of phone numbers (an array):

{

     "firstName": "John",

     "lastName": "Smith",

     "address": {

         "streetAddress": "21 2nd Street",

         "city": "New York",

         "state": "NY",

         "postalCode": 10021

},

     "phoneNumbers": {

         "212 555-1234",

         "646 555-4567"

}

}

Although JSON was based on a subset of the JavaScript programming language (specifically, Standard ECMA-262 3rd Edition-December 1999) and is commonly used with that language, it is considered to be a language-independent data format. Code for parsing and generating JSON data is readily available for a large variety of programming languages. The http://json.org website provides a comprehensive listing of existing JSON bindings, organized by language.

Although JSON is intended as a data serialization format, its design as a subset of the JavaScript programming language poses several security concerns. These concerns center on the use of a JavaScript interpreter to dynamically execute JSON text as JavaScript, thus exposing a program to errant or malicious script contained therein - often a chief concern when dealing with data retrieved from the internet.

Fortify SCA

2009-09-27T23:36:00.001-07:00

Fortify® Source Code Analysis (SCA) is the most widely used and effective solution to find and fix software vulnerabilities at the root cause early in the development cycle. Its advanced features help developers identify and resolve issues with less effort, while enabling security leads to review and prioritize more code in less time.

It supports a wide variety of languages, frameworks and operating systems and delivers depth and accuracy in its results. It can be tuned to be comprehensive when completeness is needed or extremely targeted for day-to-day use. Fortify SCA makes triage, audits and remediation fast and effective for any organization.

Fortify SCA's comprehensive source code analysis engine detects a wide variety of vulnerabilities using specialized analyzers:

Data Flow Analyzer tracks tainted input across application architecture tiers and programming language boundaries,
Semantic Analyzer detects use of vulnerable functions or procedures and understands the context of their use,
Control Flow Analyzer accurately tracks sequencing of operations to detect improper coding constructs,
Configuration Analyzer finds vulnerabilities in interactions between configurations, and
Code Structural Analysis identifies vulnerabilities or problems arising from code structures.

It uses various analysis techniques such as Buffer Overflow Analysis, Deviation Analysis, Infeasible Path Analysis, etc.

Fortify SCA supports a wide variety of development environments, languages, platforms and frameworks to enable security reviews in mixed software development and production environments:

LANGUAGES	ASP.NET, C/C++, C#, COBOL, Classic ASP/VB6, ColdFusion, Java, JavaScript, JSP, .NET, PL/SQL, PHP, T-SQL, XML
PLATFORMS	Windows, Solaris, Linux, Mac OS X, HP-UX, AIX
FRAMEWORKS	J2EE/EJB, Struts, Hibernate
IDEs	Microsoft Visual Studio, Eclipse, WebSphere Application Developer, IBM Rational Application Developer and RSA

For more information, visit http://www.fortify.com/products/detect/in_development.jsp

PREfast

2009-09-27T23:35:00.001-07:00

PREfast is a static analysis tool that identifies defects in C/C++ programs. It uses your existing build structure and works by intercepting your native compiler. Intra-procedural analysis identifies defects in the C/C++ source files.

Users commonly run PREfast over a section of code, view results, make fixes, and then run PREfast again. It is recommended that you divide your build into small (10 MB or less) sections, and run PREfast on each section.

PREfast displays a log of the code defects encountered. Each line entry in the log shows a description of the type of defect, a PREfast warning number, the source location, and function where the defect occurred.

The following defect message indicates that PREfast warning 501 occurred in function main, where PREfast found an HRESULT cast to a BOOL at line 21 of the source program test1.cpp.

Casting HRESULT to BOOL   501   c:\prefast\test\test1.cpp(21)   main 

To execute PREfast, use whatever build command you normally use at the command line, prefaced by the word prefast. Follow the build command with command-specific arguments, as shown in the following command:

prefast   

PREfast recognizes three standard build commands:

cl cl-arguments

Compiles and runs PREfast on an individual file and prints the PREfast results textually.

E.g. prefast cl /c test.c 

nmake nmake-arguments

Performs an Nmake and runs PREfast on all compiled files and prints the PREfast results textually. Any nmake-arguments are passed as arguments to Nmake.

E.g. prefast nmake /f pfw_build.mak  

build build-arguments

Performs an Nmake and runs PREfast on all compiled files and prints the PREfast results textually. Any build-arguments are passed as arguments to build.

E.g. prefast build /cefZ  

You can use one of four PREfast-specific commands to customize PREfast:

HELP	Opens the PREfast user guide.
LIST	Writes the defect log to the console.
RESET	Removes all existing defects from the defect log.
VIEW	Displays the user interface for the PREfast defect log.

PerfMon

2009-09-27T23:34:00.001-07:00

PerfMon allows you to open a Performance console configured with settings files from Windows NT 4.0 version of Performance Monitor.

perfmon.exe [file_name] [/HTMLFILE:converted_file settings_file]

Parameters

.exe

Specifies the name of the file extension.

file_name

Specifies the name of the settings file.

/HTMLFILE:converted_file settings_file

Specifies the name of the converted files, and the name of the original Windows NT 4.0 settings file.

This procedure works for the following types of Windows NT 4.0 version of Performance Monitor settings files: chart (.pmc), report (.pmr), alert (.pma), and log (.pml). To display the Windows NT 4.0 settings file in System Monitor, the system temporarily converts the file for use with Windows XP System Monitor, then discards the converted version after the console starts.

If you want to save the settings file for permanent use with System Monitor, type:

Perfmon [file_name] [/HTMLFILE:converted_file settings_file]

Where /HTMLFILE:converted_file is the name given to the converted file and settings_file is the name of the original Windows NT 4.0 settings file.

SOA

2009-09-27T23:33:00.001-07:00

Service Oriented Architecture (SOA), at an abstract level, is an architectural style whose goal is to achieve loose coupling among interacting software agents. A service is a unit of work done by a service provider to achieve desired end results for a service consumer.

SOA is a software architecture where functionality is grouped around business processes and packaged as interoperable services. It also describes IT infrastructure which allows different applications to exchange data with one another as they participate in business processes. The aim is a loose coupling of services with operating systems, programming languages and other technologies which underlie applications. SOA separates functions into distinct units, or services, which are made accessible over a network in order that they can be combined and reused in the production of business applications. These services communicate with each other by passing data from one service to another, or by coordinating an activity between two or more services.

VSS is Volume Shadow Copy Service

2009-09-27T23:32:00.000-07:00

The Volume Shadow Copy Service (VSS) is a set of COM APIs that implements a framework to allow volume backups to be performed while applications on a system continue to write to the volumes. It provides the backup infrastructure as well as a mechanism for creating consistent point-in-time copies of data known as shadow copies. It can produce consistent shadow copies by coordinating with business applications, file-system services, backup applications, fast-recovery solutions, and storage hardware. VSS provides a consistent interface that allows coordination between user applications that update data on disk (writers) and those that back up applications (requesters).

The Volume Shadow Copy Service (VSS) captures and copies stable images for backup on running systems, particularly servers, without unduly degrading the performance and stability of the services they provide. The VSS service starts on demand; therefore, for VSS operations to be successful, this service must be enabled.

Though largely transparent to user and developer, VSS does the following:

Coordinates activities of providers, writers, and requesters in the creation and use of shadow copies.
Furnishes the default system provider.
Implements low-level driver functionality necessary for any provider to work.

There are two methods for creating shadow copies: making either a complete copy (a full copy or clone) or copying only the changes to the volume (a differential copy or copy-on-write). Each method results in two data images - the original volume and the shadow copy volume. The functional difference between the two is that the original volume maintains full read/write capabilities, whereas the shadow copy volume is read-only. This read-only status ensures that the shadow copy volume remains a point-in-time copy until its status is changed by the administrator for a specific purpose.

Keywords of VSS:
Volume Shadow Copy Service	A service that coordinates various components to create consistent shadow copies of one or more volumes.
Requestor	An application that requests that a volume shadow copy be taken. A backup application is an example.
Writer	A component of an application that stores persistent information on one or more volumes that participate in shadow copy synchronization. Typically, this is a database application like SQL Server or Exchange Server, or a system service like Active Directory.
Provider	A component that creates and maintains the shadow copies. Examples are the system provider included with the operating system and the hardware providers included with storage arrays.
Source volume	The volume that contains the data to be shadow copied.
Storage volume	The volume that holds the shadow copy storage files for the system copy-on-write software provider.

Generics - A new feature in CLR and C# version 2.0

2009-09-27T23:29:00.001-07:00

The .NET Framework 2.0 introduces generics to allow you to create flexible, reusable code. Language features collectively known as generics act as templates that allow classes, structures, interfaces, methods, and delegates to be declared and defined with unspecified or generic type parameters instead of specific types. Actual types are specified later when the generic is used. The new System.Collections.Generic namespace provides support for strongly typed collections. System.Nullable is a standard representation of optional values.

Use generic types to maximize code reuse, type safety, and performance. The most common use of generics is to create collection classes. You can create your own generic interfaces, classes, methods, events and delegates. Generic classes may be constrained to enable access to methods on particular data types.

E.g.

Stack - Represents a variable size last-in-first-out(LIFO) collection of instances of the same arbitrary type.

Stack numbers = new Stack();

numbers.Push("One");

numbers.Push("Two");

numbers.Push("Three");

numbers.Push("Four");

// A stack can be enumerated without disturbing its contents.

foreach (string number in numbers)

{

      Console.WriteLine(number);

}

Information on the types used in a generic data type may be obtained at run-time by means of reflection.

SAN is Storage Area Network

2009-09-27T23:27:00.001-07:00

Storage area network (SAN) is a high-speed sub-network of shared storage devices. It contains nothing but disks for storing data. A SAN's architecture works in a way that makes all storage devices available to all servers on a LAN or WAN. It is an architecture to attach remote computer storage devices such as disk arrays, tape libraries, etc. to servers such that the devices appear as locally attached to the operating system. Because stored data does not reside directly on any of a network's servers, server power is utilized for business applications, and network capacity is released to the end user.

Devices on the SAN are normally connected together through a special kind of switch, called a Fiber Channel switch, which performs basically the same function as a switch on an Ethernet network, in that it acts as a connectivity point for the devices. Because Fiber channel is a switched technology, it is able to provide a dedicated path between the devices in the fabric so that they can utilize the entire bandwidth for the duration of the communication.

Sharing storage usually simplifies storage administration and adds flexibility since cables and storage devices do not have to be physically moved to move storage from one server to another. Other benefits include the ability to allow servers to boot from the SAN itself. This allows for a quick and easy replacement of faulty servers since the SAN can be reconfigured so that a replacement server can use the LUN of the faulty server.

SANs also tend to enable more effective disaster recovery processes. A SAN could span a distant location containing a secondary storage array. This enables storage replication either implemented by disk array controllers, by server software, or by specialized SAN devices.

ClickOnce

2009-09-27T23:26:00.001-07:00

ClickOnce is a deployment technology that enables you to create self-updating Windows-based applications that can be installed and run with minimal user interaction. ClickOnce deployment overcomes three major issues in deployment:

Difficulties in updating applications

- With Microsoft Windows Installer deployment, whenever an application is updated, the user must reinstall the whole application.

- With ClickOnce deployment, you can provide updates automatically. Only those parts of the application that have changed are downloaded, and then the full, updated application is reinstalled from a new side-by-side folder.

Impact to the user's computer

- With Windows Installer deployment, applications often rely on shared components, with the potential for versioning conflicts.

- With ClickOnce deployment, each application is self-contained and cannot interfere with other applications.

Security permissions

- Windows Installer deployment requires administrative permissions and allows only limited user installation.

- ClickOnce deployment enables non-administrative users to install and grants only those Code Access Security permissions necessary for the application.

Developers chose Web applications instead of Windows-based applications, sacrificing the rich user interface and responsiveness of Windows Forms for ease of installation. But now, by using applications deployed using ClickOnce, you can have the best of both technologies.

Simple definition of a ClickOnce application is: any Windows Presentation Foundation, Windows Forms, or console application published using ClickOnce technology. Salient features include:

You can publish a ClickOnce application in three different ways: from a Web page, from a network file share, or from media such as a CD-ROM. A ClickOnce application can be installed on an end user's computer and run locally even when the computer is offline, or it can be run in an online-only mode without permanently installing anything on the end user's computer.
ClickOnce applications can be self-updating; they can check for newer versions as they become available and automatically replace any updated files.
Because ClickOnce applications are isolated, installing or running a ClickOnce application cannot break existing applications. ClickOnce applications are self-contained; each ClickOnce application is installed to and run from a secure per-user, per-application cache. By default, ClickOnce applications run in the Internet or Intranet security zones. If necessary, the application can request elevated security permissions.

Purify

2009-09-27T23:25:00.001-07:00

Purify is a memory debugger program used by software developers to detect memory access errors in programs, especially those written in C or C++.

Purify allows dynamic verification, a process by which a program discovers errors that occur when the program runs, much like a debugger. Static verification or static code analysis, by contrast, involves detecting errors in the source code without ever compiling or running it, just by discovering logical inconsistencies.

When a program is linked with Purify, corrected verification code is automatically inserted into the executable by parsing and adding to the object code, including libraries. That way, if a memory error occurs, the program will print out the exact location of the error, the memory address involved, and other relevant information. Purify also detects memory leaks. By default, a leak report is generated at program exit but can also be generated by calling the Purify leak-detection API from within an instrumented application.

The errors that Purify discovers include array bounds reads and writes, trying to access unallocated memory, freeing unallocated memory (usually due to freeing the same memory for the second time), as well as memory leaks (allocated memory with no pointer reference). It is essential to note that most of these errors are not fatal (at least not at the site of the error), and often when just running the program there is no way to detect them, except by observing that something is wrong due to incorrect program behavior. Hence Purify helps enormously by detecting these errors and telling the programmer exactly where they occur. Because Purify works by instrumenting all the object code, it detects errors that occur inside of third-party or operating system libraries. These errors are often caused by the programmer passing incorrect arguments to the library calls, or by misunderstandings about the protocols for freeing data structures used by the libraries. These are often the most difficult errors to find and fix.

With Purify's just-in-time (JIT) debugging, you can use your debugger to investigate errors even when you run your application from outside the debugger. You can have Purify automatically attach a debugger to your application when selected types of Purify messages are reported, or have Purify ask you if you want to start a debugger at the time of the error. You can also use JIT debugging to start your debugger when it encounters a watch-point message. Purify stops just before the watch-point.

Ref: http://www-01.ibm.com/software/awdtools/purify/support/doc.html

UNO is Universal Network Objects

2009-09-27T23:22:00.000-07:00

UNO is a component model that offers inter-operability between different programming languages, different objects models, different machine architectures, and different processes; either in a LAN or via the Internet. UNO is freely available and currently supports Java, C and C++ (on windows, Linux, and Solaris). A bridge for COM OLE Automation already exists. UNO is developed by the OpenOffice.org community including the Sun Microsystems development labs.

UNO is interface based, as are COM and CORBA. Components implement interfaces compliant to their interface specification. Multiple components communicate only via their interfaces. This allows implementing one component in a different language or to move an implementation to another machine, without modifying the other's components. This gives you huge flexibility and preserves earlier invested efforts.

Each component lives in a Uno Runtime Environment (URE). A URE is identified by the implementation language and the current process. There is no performance overhead for components, that are instantiated within the same URE, e.g., in C++, a call from component A to B is just a virtual call. The calls between components from different UREs are bridged by UNO.

In general, calls are bridged through a single dispatch method. This method is, in general, easy to implement for inter-process bridges or bridges to interpreting languages. There is no generated code for stubs or proxies. All necessary conversions are done by the generic dispatch method. The information about the method signature is retrieved dynamically from a type library. This type library is reused by every bridge, so only the number of entries in the type library grows with a growing number of types. This reduces build time and memory consumption at runtime; nevertheless, bridging is as fast as generated code.

UNO-interfaces are specified in IDL. All UNO-interfaces must be derived from a super interface, that offers acquire, release, and a QueryInterface() method (comparable to COM). The lifetime of UNO-objects is controlled by global reference counting. Exceptions are used for error handling.

UNO guarantees object identity, thread identity, and the sequence of calls.

Object Identity - Two interfaces' references can be compared for equality. UNO guarantees, that the result is correct, no matter whether the result is true or false.
Thread Identity - In UNO every thread is named by a globally unique thread identifier. A thread leaving the process via an inter-process bridge is identified when entering the process, again, some callstack levels higher. The same thread will execute the new call thus guaranteeing that any thread dependent resources stay the same (such as thread local storage, lock of mutexes, etc.).
Sequence of Calls - UNO allows declaring a method one way (or asynchron). Multiple, one way calls are guaranteed to be executed in the same sequence as they were called.

A sequence of one way calls can be transferred and executed extremely fast via an inter-process connection. The UNO inter-process protocol is optimized for low bandwidth connections.

Ref: http://udk.openoffice.org/

M

2009-09-27T22:01:00.001-07:00

The Microsoft code name "M" language is a declarative language for working with data and building domain models. It is used by the "Oslo" Modeling platform. M lets users write down how they want to structure and query their data using a textual syntax that is convenient to both author and reader. M does not mandate how data is stored or accessed, nor does it mandate a specific implementation technology. Rather, M is designed to allow users to write down what they want from their data without having to specify how those requirements are met by a specific technology or platform.

The Oslo Modeling Language, M, is a language for modeling domains using text. A key advantage of modeling in text is ease with which both computers and humans can store and process text. The language feature of M enables information to be represented in a textual form that is tuned for both the problem domain and the target audience. The M language provides simple constructs for describing the shape of a textual language - that shape includes the input syntax as well as the structure and contents of the underlying information. To that end, M acts as both a schema language that can validate that textual input conforms to a given language as well as a transformation language that projects textual input into data structures that are amenable to further processing or storage.

C# Indexers

2009-09-27T21:59:00.000-07:00

Indexers permit instances of a class or struct to be indexed in the same way as arrays. Indexers are similar to properties except that their accessors take parameters. To declare an indexer on a class or struct, use the “this” keyword as shown below:

// Indexer declaration
public int this[int index]
{
   // get and set accessors
}

The type of an indexer and the type of its parameters must be at least as accessible as the indexer itself. The signature of an indexer consists of the number and types of its formal parameters. It does not include the indexer type or the names of the formal parameters. If you declare more than one indexer in the same class, they must have different signatures. An indexer value is not classified as a variable; therefore, it is not possible to pass an indexer value as a ref or out parameter.

// Using a string as an indexer value
class DayCollection
{
   string[] days = { "Sun", "Mon", "Tues", "Wed", "Thurs", "Fri", "Sat" };

   // This method finds the day or returns -1
   private int GetDay(string testDay)
   {
   int i = 0;
   foreach (string day in days)
   {
   if (day == testDay)
   {
   return i;
   }
   i++;
   }
   return -1;
   }

   // The get accessor returns an integer for a given string
   public int this[string day]
   {
   get
   {
   return (GetDay(day));
   }
   }
}

class Program
{
   static void Main(string[] args)
   {
   DayCollection week = new DayCollection();
   System.Console.WriteLine(week["Fri"]);
   System.Console.WriteLine(week["Made-up Day"]);
   }
}

* Indexers enable objects to be indexed in a similar way to arrays.
* A get accessor returns a value. A set accessor assigns a value.
* The “this” keyword is used to define the indexers.
* The value keyword is used to define the value being assigned by the set indexer.
* Indexers do not have to be indexed by an integer value; it is up to you how to define the specific look-up mechanism.
* Indexers can be overloaded.
* Indexers can have more than one formal parameter, for example, when accessing a two-dimensional array.

There are two main ways in which the security and reliability of indexers can be improved:
* Always ensure that your code performs range and type checks when setting and retrieving values from any buffer or array accessed by the indexers.
* Set the accessibility of the get and set accessors to be as restrictive as is reasonable. This is important for the set accessor in particular.

GAC is Global Assembly Cache

2009-09-27T21:56:00.001-07:00

Each computer where the CLR (common language runtime) is installed has a machine-wide code cache called the “Global Assembly Cache”. The global assembly cache stores assemblies specifically designated to be shared by several applications on the computer.

You should share assemblies by installing them into the global assembly cache only when you need to. As a general guideline, keep assembly dependencies private, and locate assemblies in the application directory unless sharing an assembly is explicitly required. In addition, it is not necessary to install assemblies into the global assembly cache to make them accessible to COM interop or unmanaged code.

There are several reasons why you might want to install an assembly into the global assembly cache:
* Shared location - Assemblies that should be used by applications can be put in the global assembly cache.
E.g. If all applications should use an assembly located in the global assembly cache, a version policy statement can be added to the Machine.config file that redirects references to the assembly.
* File security - Administrators often protect the SYSTEMROOT directory using an Access Control List (ACL) to control write and execute access. Because the global assembly cache is installed in the SYSTEMROOT directory, it inherits that directory's ACL. It is recommended that only users with Administrator privileges be allowed to delete files from the global assembly cache.
* Side-by-side versioning - Multiple copies of assemblies with the same name but different version information can be maintained in the global assembly cache.
* Additional search location - The common language runtime checks the global assembly cache for an assembly that matches the assembly request before probing or using the codebase information in a configuration file.

There are several ways to deploy an assembly into the global assembly cache:
* Use an installer designed to work with the global assembly cache. This is the preferred option for installing assemblies into the global assembly cache.
* Use a developer tool called the Global Assembly Cache tool (Gacutil.exe), provided by the Windows Software Development Kit (SDK).
* Use Windows Explorer to drag assemblies into the cache.

Assemblies deployed in the global assembly cache must have a strong name. When an assembly is added to the global assembly cache, integrity checks are performed on all files that make up the assembly. The cache performs these integrity checks to ensure that an assembly has not been tampered with, e.g. when a file has changed but the manifest does not reflect the change.

To view a list of the assemblies in the global assembly cache, type the following command at the command prompt - gacutil -l

DLR is Dynamic Language Runtime

2009-09-27T21:53:00.000-07:00

The Dynamic Language Runtime (DLR) from Microsoft is an ongoing effort to bring a set of services that run on top of the Common Language Runtime (CLR) and provides language services for several different dynamic languages. These services include:
* A dynamic type system, to be shared by all languages utilizing the DLR services
* Dynamic method dispatch
* Dynamic code generation
* Hosting API

The DLR will be used to implement dynamic languages like Python and Ruby on the .NET Framework. The DLR services are currently used in the development versions of IronRuby, a .NET implementation of the Ruby language, and the upcoming IronPython 2.0.Microsoft plans to use the DLR for the upcoming Visual Basic .NET 10.0 (VBx) and Managed JScript (ECMAScript 3.0).

By having several dynamic language implementations share a common underlying system, it should be easier to let these implementations interact with one another. For example, it should be possible to use libraries from any dynamic language in any other dynamic language. In addition, the hosting API allows interoperability with statically typed CLI languages like C#.

The Dynamic Language Runtime is built on the idea that it is possible to implement language specificities on top of a generic language-agnostic abstract syntax tree, whose nodes correspond to a specific functionality that is common to many dynamic languages. This architecture is backed by the idea that the number of elementary language constructs that would have to be implemented on the generic stack should be inherently limited. The DLR dynamically generates code corresponding to the functionality expressed by these nodes. The compiler for any dynamic language implemented on top of the DLR has to generate DLR abstract trees, and hand it over to the DLR libraries.

The DLR provides dynamically-updated DynamicSite objects that cache the task of binding methods to objects. Since in dynamic languages, the type of an object, as well as the members it contains, can change during a program lifetime, a method invocation must check the method list to see if the invocation is a valid one. DynamicSite objects represent and cache the state of the object and its methods; any update to the object is reflected in the DynamicSite objects as well. DLR routes all method invocations via the DynamicSite objects, which then performs a fast lookup and binding of the method with the actual implementation.

Flex

2009-09-27T21:51:00.000-07:00

Adobe Flex can be used to create engaging, cross-platform rich Internet applications. Flex is a highly productive, free open source framework for building and maintaining expressive web applications that deploy consistently on all major browsers, desktops, and operating systems. While Flex applications can be built using only the free Flex SDK, developers can use Adobe® Flex® Builder 3 software to dramatically accelerate development.

Traditional application programmers found it challenging to adapt to the animation metaphor upon which the Flash Platform was originally designed. Flex seeks to minimize this problem by providing a workflow and programming model that is familiar to these developers. MXML, an XML-based markup language, offers a way to build and lay out graphic user interfaces. Interactivity is achieved through the use of ActionScript, the core language of Flash Player that is based on the ECMAScript standard.

The Flex SDK comes with a set of user interface components including buttons, list boxes, trees, data grids, several text controls, and various layout containers. Charts and graphs are available as an add-on. Other features like web services, drag and drop, modal dialogs, animation effects, application states, form validation, and other interactions round out the application framework.

In a multi-tiered model, Flex applications serve as the presentation tier. Unlike page-based HTML applications, Flex applications provide a stateful client where significant changes to the view don't require loading a new page. Similarly, Flex and Flash Player provide many useful ways to send and load data to and from server-side components without requiring the client to reload the view. Though this functionality offered advantages over HTML and JavaScript development in the past, the increased support for XMLHttpRequest in major browsers has made asynchronous data loading a common practice in HTML-based development as well.

Technologies that are commonly compared to Flex include OpenLaszlo, Ajax, XUL, JavaFX and Windows Presentation Foundation technologies such as Silverlight.
Ref: http://www.adobe.com/devnet/flex/

To view a few sample applications created using rich UI with Flex, visit:
http://examples.adobe.com/flex2/inproduct/sdk/restaurant/finder.html
http://blogs.ilog.com/elixir/2009/01/30/factbook2/
http://examples.adobe.com/flex2/inproduct/sdk/flexstore/flexstore.html

Cloud Computing

2009-09-27T21:10:00.000-07:00

Cloud computing refers to the use of Internet ("cloud") based computer technology for a variety of services. It is a style of computing in which dynamically scalable and often virtualized resources are provided as a service over the Internet. Users need not have knowledge of, expertise in, or control over the technology infrastructure "in the cloud" that supports them.

The concept incorporates software as a service (SaaS), Web 2.0 and other recent, well-known technology trends, in which the common theme is reliance on the Internet for satisfying the computing needs of the users. E.g. Google Apps which provide common business applications online that are accessed from a web browser, while the software and data are stored on the servers.

The majority of cloud computing infrastructure consists of reliable services delivered through data centers and built on servers with different levels of virtualization technologies. The services are accessible anywhere in the world, with The Cloud appearing as a single point of access for all the computing needs of consumers. Commercial offerings need to meet the quality of service requirements of customers and typically offer service level agreements. Open standards and open source software are also critical to the growth of cloud computing.

As customers generally do not own the infrastructure, they merely access or rent, they can avoid capital expenditure and consume resources as a service, paying instead for what they use. Many cloud-computing offerings have adopted the utility computing model, which is analogous to how traditional utilities like electricity are consumed, while others are billed on a subscription basis. Sharing "perishable and intangible" computing power among multiple tenants can improve utilization rates, as servers are not left idle, which can reduce costs significantly while increasing the speed of application development. A side effect of this approach is that "computer capacity rises dramatically" as customers do not have to engineer for peak loads.

Providers including Amazon, Google and Yahoo exemplify the use of cloud computing. Recently, Microsoft has introduced its new Cloud Computing service as a part of Windows Azure. These services can be accessed through Microsoft Visual Studio by installing the Windows Azure SDK and Windows Azure Tools for Visual Studio 2008.
Ref: http://www.microsoft.com/downloads/details.aspx?familyid=80e3eabf-0507-4560-aeb6-d31e9a70a0a6&displaylang=en
http://www.microsoft.com/downloads/details.aspx?FamilyID=8e90b639-1ef0-4e21-bb73-fc22662911bc&displaylang=en

F# (Pronounced as F Sharp)

2009-09-27T21:08:00.000-07:00

Microsoft pronounces F# as its succinct, type-inferred, expressive, efficient functional and object-oriented language for the .NET platform. F# is developed as a research programming language to provide the much sought-after combination of type safety, succinctness, performance, expressivity and scripting, with all the advantages of running on a high-quality, well-supported modern runtime system. This combination has been so successful that the language is now being transitioned towards a fully supported language on the .NET platform. Some of the reasons for this move are that F# gives you:
* Succinct, type-inferred functional programming,
* Interactive scripting like Python and other languages,
* Foundations for an interactive data visualization environment,
* Combination of type inference and safety, like that of ML,
* A cross-compiling core shared with the popular Objective Caml language,
* A performance profile like that of C#,
* Easy access to the entire range of powerful .NET libraries and database tools,
* A foundational simplicity with similar roots to Scheme,
* Option of a top-rate Visual Studio integration, which is usable with the freely available Visual Studio 2008 Shell
* Experience of a first-class team of language researchers with a track record of delivering high-quality implementations,
* Speed of native code execution on the concurrent, portable, and distributed .NET Framework.

F# was developed as a pragmatically-oriented variant of ML that shares a core language with Objective Caml. Unlike other scripting languages it executes at or near the speed of C# and C++, making use of the performance that comes through strong typing. Unlike many type-inferred, statically-typed languages it also supports many dynamic language techniques, such as property discovery and reflection where needed. F# includes extensions for working across languages and for object-oriented programming and it works seamlessly with other .NET programming languages and tools.

Ref: http://research.microsoft.com/en-us/um/people/curtisvv/fsharp_default.aspx

BoundsChecker

2009-09-27T21:03:00.000-07:00

DevPartner for Visual C++ detects and analyzes runtime errors, pinpoints performance bottlenecks and verifies test coverage in order to increase code quality and reduce development and testing time through increased productivity. The tool suite integrates seamlessly with Visual Studio for maximum usability within the development environment. BoundsChecker is a memory checking tool used for C++ software development with Microsoft Visual C++. It is part of the DevPartner for Visual C++ BoundsChecker Suite.

BoundsChecker’s error detection technology provides developers with a clear, detailed analysis of programming errors in unmanaged Visual C++ code. It automatically monitors the runtime behavior of the code—how it accesses memory, how it calls APIs and how it uses COM interfaces and methods. Without any special compilation or build steps, developers and testers can automatically locate errors in static, stack and heap memory, and can detect and diagnose memory and resource leaks. This technology enables Visual C++ native application developers to:
* Locate a large variety of memory and resource problems including leaks, overrun errors and pointer problems;
* Rapidly sort errors and leaks by size, frequency and type to identify and prioritize critical problems;
* Check for errors in any native application or component, including proprietary and third-party components and libraries—even when the original source code is unavailable;
* Detect thread deadlocks, potential deadlocks and other synchronization problems;
* Locate incorrect usage or failed API calls in any native application component, DLL or EXE, including Win32, ActiveX, DirectX, ODBC, Winsock, Internet APIs and more.

Ref: http://www.compuware.com/products/devpartner/visualc.htm

Aspect Oriented Programming (AOP)

2009-09-27T20:58:00.000-07:00

Aspect-oriented programming (AOP) is a programming paradigm that increases modularity by allowing the separation of cross-cutting concerns, forming a basis for aspect-oriented software development. This involves breaking down a program into distinct parts (concerns). All programming paradigms support some level of grouping and encapsulation of concerns into separate, independent entities by providing abstractions (e.g. procedures, modules, classes, methods) that can be used to implement, abstract and compose these concerns. But some concerns defy these forms of implementation and are called crosscutting concerns because they "cut across" multiple abstractions in a program.

Logging is a common example of a crosscutting concern because a logging strategy necessarily affects every single logged part of the system. Logging thereby crosscuts all logged classes and methods.

All AOP implementations have some crosscutting expressions that encapsulate each concern in one place. The difference between implementations lies in the power, safety, and usability of the constructs provided. AspectJ has a number of such expressions and encapsulates them in a special class, an aspect. For example, an aspect can alter the behavior of the base code (the non-aspect part of a program) by applying advice (additional behavior) at various join points (points in a program) specified in a quantification or query called a pointcut (that detects whether a given join point matches). An aspect can also make binary-compatible structural changes to other classes, like adding members or parents.

AOP allows the programmer to express cross-cutting concerns in stand-alone modules called aspects. Aspects can contain advice (code joined to specified points in the program) and inter-type declarations (structural members added to other classes). For example, a security module can include advice that performs a security check before accessing a bank account. The pointcut defines the times (join points) that a bank account can be accessed, and the code in the advice body defines how the security check is implemented. That way, both the check and the places can be maintained in one place. Further, a good pointcut can anticipate later program changes, so if another developer creates a new method to access the bank account, the advice will apply to the new method when it executes.

The following are some standard terminology used in Aspect-oriented programming:

* Cross-cutting concerns: Even though most classes in an OO model will perform a single, specific function, they often share common, secondary requirements with other classes. For example, we may want to add logging to classes within the data-access layer and also to classes in the UI layer whenever a thread enters or exits a method. Even though the primary functionality of each class is very different, the code needed to perform the secondary functionality is often identical.

* Advice: This is the additional code that you want to apply to your existing model. In our example, this is the logging code that we want to apply whenever the thread enters or exits a method.

* Pointcut: This is the term given to the point of execution in the application at which cross-cutting concern needs to be applied. In our example, a pointcut is reached when the thread enters a method, and another pointcut is reached when the thread exits the method.

* Aspect: The combination of the pointcut and the advice is termed an aspect. In the example below, we add a logging aspect to our application by defining a pointcut and giving the correct advice.

Good hikes around Santa Clara, CA, USA

2009-09-27T00:18:00.001-07:00

Castle Rock State Park, California State Parks

http://www.bahiker.com/southbayhikes/castlerock.html

Stevens Creek County Park/ Fremont Older Open Space Preserve,

Santa Clara County Parks/Midpeninsula Regional Open Space District, Santa Clara County

http://www.bahiker.com/southbayhikes/stevenscreek.html

Midpeninsul regional open space

http://www.bahiker.com/southbayhikes/stevenscreek.html

Salsa Dance Steps

2009-09-20T09:50:00.001-07:00

Basic
Side ways Basic
Cross body
Cross body with inner turn
Hair brush
Hammer lock
Titanic (Left over Right)
Cacoon
girl and boy turning
Double hands
Natural Top

Body Parts for Exercising

2009-09-20T09:48:00.000-07:00

Arms

Biceps
Triceps
Wrist

Chest
Back

Upper back
Lower back

Legs

Thigh
Calf
Hamstring
Adductors

Shoulders
Abdomin (Stomach)

Upper pack
Middle pack
Lower pack

Face

Combo 1:

Chest
Upper back
Legs
Abdomin

Combo 2:

Arms
Legs
Abdomin

Combo 3:

Shoulders
Legs
Abdomin

Nutrition Terminology

2009-09-20T00:55:00.000-07:00

Nutrients:

Vitamines
Minerals
Carbohydrates
Fats
Proteins
Fibers
water

Water Soluble Vitamins:

Vitamin C
Vitamin B
Vitamin B12

Fat Soluble Vitamins:

Vitamin A
Vitamin D
Vitamin E
Vitamin K

Whats this?

Calcium
Phosphorus
Iron
Potassium
Sodium
B Vitamins

Digestion order:

Carbohydrates - which separate quickly into single sugar units - are absorbed first
Proteins (as amino acids) go next
Fats - which take longest to break apart into their constituent fatty acids - are last. That’s why the high-fat meal keeps you feeling fuller longer than a meal such as chow mein or plain tossed salad, which are mostly low-fat carbohydrates.
Vitamins that dissolve in water are absorbed earlier than vitamins that dissolv in fat.

Calories: The Energizers

1 Kilocalorie = Amount of energy it takes to raise the temperature of 1 kg of water 1 gegree on a Centigrade (Celsius) thermometer at sea level.
Sugar and Beer gives empty calories
If you take in more energy (calories) than you spend each day, you will gain weight. If you take in less than you use up, you will lose weight. This nutrition rile is an equal opportunity, one-size -fits-all proposition that applies to everyone.
How many calories do you need? - Think of your energy requirements as a bank account. You make deposits when you consume calories. You make withdrawals when your body spends energy on work.
1 kg = 2.2 pounds
Resting Energy Expenditure for 18 to 30 years (My weight 162 pounds = 162 / 2.2 = 73.6363 kg)

= (15.3 x weight in kg) + 679
= (15.3 x 73) + 679 = 1,795.9

Pancreas secretes insulin, a hormone that enables you to digest and metabolize carbohydrates.
Muscle weighs more than fat.
Height is measured without shoes and weight is measured without cloths.
How much should you weigh?

Height 5'9'' - weight (for 19 to 24 age) - 129 to 169 pounds
Height 5'10'' - weight (for 19 to 24 age) - 134 to 174 pounds
Height 5'11'' - weight (for 19 to 24 age) - 136 to 179 pounds

Body mass Index (BMI), a number that measures the relationship between your weight and you height and offers some predictive estimate of your risk of weight related disease. Following are US standard:

BMI below 18.5 - Underweight
BMI 18.5 to 24.9 - Normal
BMI 25 to 29.9 - Overweight
BMI 30 or higher - Obese

To calculate BMI :

Divide your weight in pounds by your height in inches squared
Multiply the result of step a by 705

My weight = 162 pounds
My height = 5'9'' = (12*5) + 9 = 69
Hence My BMI = (162/(69*69)) * 705 = 23.9887

Healthiest BMI = 21.0

High Calorie ingredients

Saturated fats

One Pound of body fat equals 3500 calories
Calories required per day

Age 19-30
Sedentary lifestyle - 2400
Moderately active lifestyle - 2600 - 2800
Active lifestyle - 3000

Talks Ken Robinson says schools kill creativity

2009-09-17T23:58:00.001-07:00

Talks Pilobolus perform "Symbiosis"

2009-09-17T23:56:00.000-07:00

Talks Euvin Naidoo on investing in Africa

2009-09-17T23:55:00.000-07:00

Talks Barry Schwartz on the paradox of choice

2009-09-17T23:52:00.001-07:00

Talks Nandan Nilekani's ideas for India's future

2009-09-17T23:51:00.001-07:00

Talks Andrew Mwenda takes a new look at Afric

2009-09-17T23:46:00.000-07:00

Interesting TED Video!

Crop Circles : A Mystery of Modern Times

2009-09-17T23:33:00.000-07:00

Just came acorss an amazing phenomenon called Crop Cricles, check it for yourself here.

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

Document list required for NRI Home Loan sanction

2009-09-12T10:34:00.000-07:00

List of docs

1. Photo copy of Valid passport

2. Photo copy of Latest valid visa

3. Social security card copy (Format Attached)

4. Employer contract copy or appointment letter copy

5. Photo copy / print out of latest three months pay slips / certificates with deductions

6. Photo copy of Address proof in India

7. POA as per attached format.

8. Photo copy / Print out of Last 6 months updated bank statement (foreign -salary account)

9. Photo copy / print out of last 6 months updated NRI account (In India).

10. Coloured Passport Size Photo of applicant & co-applicant- one each

11. Self declaration form (Format Attached DO NOT PUT THE DATE)

12. Admin fee cheque of 0.5% of the Loan Amount+ service tax 10.30% of Admin fee favoring

" HFC Ltd for loan A/c of Mr. _________" from NRI account

13. Self-attestation on all the photo copies / print outs as per above list

Personal details required:

1. Detail address of overseas with nearest landmark i. e. city, district, state.

2. Mobile number & land line number with ISD code.

3. No. of your stay at USA.

4. Employer details with detail address.

5. Employer phone number with ISD code, Fax number.

6. Your official mail ID & no. of employees working in your company.

7. Your designation & department.

8. No of years in this company or abroad.

9. Details of asset base (like house property, LIC, Shares & Securities)

10. Details of existing loans (Financial company, EMI, Loan amount, Balance EMI, Purpose of the loan)

11. Credit Card details.

12. Details of overseas bank account (Date of opening, type of A/C, Account number, Statement for last six months)

All the above information can be sent in email but following forms needs to be sent in hard copy.

1. Credit verification form

2. NRI Declaration form

3. NRI POA for HFC

Housing Loan in India FAQ

2009-09-12T09:59:00.000-07:00

Terms used in Housing Finance :

EMI: Equated Monthly Installment till the loan is paid back. It consists of a portion of interest and the principal
Floating Rate of interest: Rate of interest, which varies with the market-lending rate. This means that there is an element of risk of paying more than budgeted amount in case the lending rates goes up
Daily Reducing Balance: In this system interest reduces daily with the repayment of Principal amount, if repaid daily.
Monthly Reducing balance: In this system interest reduces monthly with repayment of Principal amount
Annual Reducing Balance: In this system principal is reduced annually at the end of the year so you end up paying interest even for the portion of principal you have actually paid back
Fixed rate of interest: Rate of interest remains unchanged for a certain period of the loan
Processing charge: It's a fee payable to the lender on applying for the loan
Prepayment Penalties: When loan is paid back before the agreed term of the loan, then banks/ institutions charge penalty for the prepayment
Commitment Fee: Some institution charge commitment fee in case the loan is not availed within a stipulated period, after it is processed and sanctioned
Miscellaneous Cost: It is quite possible that some lenders may charge documentation or consultant charges.

These are general FAQs, some or many of following may not be applicable to BoB (pl visit our site for prevailing T & C and latest up dates)

What is an EMI?

EMI (Equated Monthly Installment) is the amount payable to the lending institution every month, till the loan is paid back in full. It consists of a portion of the interest as well as the principal.

How is an EMI calculated?

EMI Formula: l x r [(1+r) n /(1+r) n-1] x 1/12
l = loan amount
r = rate of interest
n = term of the loan

What are the incentives offered by lending institutions?

a) Some of the lending institutions sanction the loan without requiring you to identify property as a prerequisite for eligibility

b) Free Property insurance with personal accident benefit clause insurance

c) Discounts in festival season

d) Waiving of pre payment penalty

e) Waiving of processing fee partly or fully, if special scheme announced

What are the eligibility conditions for a home loan?

To qualify for a home loan, most of the lending institutions in India require you to be:
a) An Indian resident or NRI

b) Above 21 years of age at the commencement of the loan

c) Below 65 when the loan matures

d) Either salaried or self employed, confirmed income for 3 years. Form No 16 issued by the employer & duly filed ITR’s for past 3 years.

What are the interest rates offered for home loans? What are: Daily Reducing, Monthly Reducing and Yearly Reducing?

Interest rates are different from institution to institution and generally range from about 8.50% to around 12 %. The interest on home loans in India is usually calculated either on monthly reducing or yearly reducing balance. In some cases, daily reducing basis is also adopted.

Annual reducing:
In this system, the principal, for which you pay interest, reduces at the end of the year. Thus you continue to pay interest on a certain portion of the principal, which you have actually paid back to the lender. This means the EMI for the monthly reducing system is effectively less than the annual reducing system.

Monthly reducing:
In this system, the principal, for which you pay interest, reduces every month as you pay your EMI.

Daily Reducing:
In this system, the principal, for which you pay interest, reduces from the day you pay your EMI. EMI in the daily reducing system is less than the monthly reducing system. If you are having facility to pay extra amount in your account other than EMI then it reduces interest being charge to your account. In simple word if you keep your EMI same & repays extra amount, your tenure will be reduced in proportionately.

What is the best way to select the cheapest home loan?

Keep the loan period constant and calculate the total amount paid for the home through the different loan options available.

What is a fixed rate of interest?

Some institutions have a fixed rate of interest, which means the rate of interest remains unchanged for the certain period of the loan. This means you do not benefit for certain period, even if rates of interest drop in the market.

What is a floating rate?

This is the rate of interest that fluctuates according to the market-lending rate. This means you stand the risk of paying more than you budgeted for in case the lending rate goes up.

What are the other costs that usually accompany a home loan?

Home loans are usually accompanied by the following extra costs:
a) Processing Charge: It's a fee payable to the lender on applying for a loan. It is either a fixed amount not linked to the loan or may also be a percentage of the loan amount. The loan amount required by you cannot be less than the processing fee.

b) Pre-payment Penalties: When a loan is paid back before the end of the agreed duration, a penalty is charged by some banks/companies, which is usually between 2% and 4% of the amount being pre-paid.

c) Commitment Fees: Some institutions levy a commitment fee in case the loan is not availed of within a stipulated period of time after it is processed and sanctioned.c) Miscellaneous Costs: It is quite possible that some lenders may levy a documentation or consultant charges. e) Registration of mortgage deed or equitable mortgage.

d) What are the repayment period options?

Repayment period options range generally from 5 to 25 years.

How do HFCs decide on the loan amount?

Usually, most companies give up to a maximum of 85% of the cost of the house. Some Banks consider agreement value + stamp duty + registration. The 15%, sometimes called margin or 'seed money', will have to be provided by the loan applicant. The amount, for which the applicant is eligible, is determined by the age, income, no. of dependents, monthly outgoing and repayment capacity. This varies from case to case.

Are securities required for home loans?

In most cases, the property to be purchased itself becomes the security and is mortgaged to the lending institution till the entire loan is repaid. Some institutions may ask for additional security such as life insurance policies, FD receipts and share or savings certificates or their own-marketed product.

Do I require a guarantor to get a home loan?

Some institutions ask for 1 or 2 guarantors, some asks local guarantor, some asks co-applicant instead of guarantor and some requires no guarantor at all.

What is the time required for loan application approval?

About 0-15 days.

What is the time required for loan disbursement?

On an average, loans are disbursed within 3-5 days after satisfactory and complete documentation and completion of all relevant procedures, including proof that 15% of the cost has been paid upfront to the seller of the property. Some times they follow 15:85 ratio.

Can I make joint applications for home loans?

Most institutions are willing to consider the joint incomes of the applicants for deciding the loan amount. Some institutions do not require the co-applicants to be co-owners of the property to be purchased.

What are the tax benefits of home loans?

Both principal as well as interest of home loans attract tax benefits. With effect from 1st April 2005 (i.e. assessment year 2005-07) under section 80C of the Income Tax Act 1965:

Principal amount of repayment of loan along with other savings such as PF, PPF, Life Insurance premium etc up to a maximum of Rs 1,00,000/- will be eligible for deduction from gross income.

Interest paid on loan after completion of construction will be deductible from income from property

For self occupied - Income will be treated as nil and interest payment will be treated as minus income which will be adjusted against other income. (At present Rs.1,50,000/- is limit)
For rental property - It will be adjusted against rental income. (Please consult your tax consultant)