HASSAN

Flash plugin on 64 bit Ubuntu

hassan4u — Mon, 22 Aug 2011 13:21:35 +0000

sudo apt-add-repository ppa:sevenmachines/flash
sudo apt-get update
sudo apt-get install flashplugin64-installer

Reference: https://help.ubuntu.com/community/AMD64/FirefoxAndPlugins

RESTing with CURL

hassan4u — Thu, 23 Jun 2011 14:54:54 +0000

Pretty nice tutorial to make REST WEB service calls using curl

http://blogs.plexibus.com/2009/01/15/rest-esting-with-curl/

Get
curl -i -H “Accept: application/json” http://192.168.0.165/persons/person/1

curl -i -H “Accept: application/json” “http://192.168.0.165/persons?firstName=james&lastName=wallis”

Delete
curl -i -H “Accept: application/json” -X DELETE http://192.168.0.165/persons/person/1

POST DATA TO REST RESOURCE
curl -i -H “Accept: application/json” -X POST -d “firstName=james” http://192.168.0.165/persons/person

PUT A RESPONSE
curl -i -H “Accept: application/json” -X PUT -d “phone=1-800-999-9999″ http://192.168.0.165/persons/person/1

POST TO PUT
curl -i -H “Accept: application/json” -H “X-HTTP-Method-Override: PUT” -X POST -d “phone=1-800-999-9999″ http://192.168.0.165/persons/person/1
POST TO DELETE
curl -i -H “Accept: application/json” -H “X-HTTP-Method-Override: DELETE” -X POST http://192.168.0.3:8090/persons/person/1

…..

BOOTSTRAP (BOOTP) protocol

hassan4u — Sun, 09 Jan 2011 15:54:36 +0000

BOOTP is usually used during the bootstrap process when a computer is starting up. A BOOTP configuration server assigns an IP address to each client from a pool of addresses. BOOTP uses the User Datagram Protocol (UDP) as a transport on IPv4 networks only.

Historically, BOOTP has also been used for Unix-like diskless workstations to obtain the network location of their boot image in addition to an IP address, and also by enterprises to roll out a pre-configured client (e.g., Windows) installation to newly installed PCs.

Internet Group Management Protocol (IGMP)

hassan4u — Sun, 09 Jan 2011 15:48:06 +0000

Internet Group Management Protocol (IGMP)

Allowshosts to specify list from which they want to receive traffic
Traffic from other hosts blocked at routers

Allowshosts to block packets from sources that send unwanted traffic

Interior vs Exterior Gateway protocol

hassan4u — Sun, 09 Jan 2011 15:34:23 +0000

INTERIOR GATEWAY PROTOCOLS

Interior Gateway Protocols (IGPs) handle routing within an Autonomous System (one routing domain). In plain English, IGP’s figure out how to get from place to place between the routers you own. These dynamic routing protocols keep track of paths used to move data from one end system to another inside a network or set of networks that you administrate (all of the networks you manage combined are usually just one Autonomous System). IGP’s are how you get all the networks communicating with each other.

IGP’s fall into two categories:

Distance Vector Protocols
Routing Information Protocol (RIP)
Interior Gateway Routing Protocol (IGRP)

Link State Protocols
Open Shortest Path First (OSPF)
Intermediate System to Intermediate System (IS-IS)

EXTERIOR GATEWAY PROTOCOLS

To get from place to place outside your network(s), i.e. on the Internet, you must use an Exterior Gateway Protocol. Exterior Gateway Protocols handle routing outside an Autonomous System and get you from your network, through your Internet provider’s network and onto any other network. BGP is used by companies with more than one Internet provider to allow them to have redundancy and load balancing of their data transported to and from the Internet.

Examples of an EGP:
Border Gateway Protocol (BGP)
Exterior Gateway Protocol (Replaced by BGP)

Ref: http://www.inetdaemon.com/tutorials/internet/ip/routing/interior_vs_exterior.shtml

IP Tunneling

hassan4u — Sun, 09 Jan 2011 10:04:39 +0000

IP tunneling (IP encapsulation) is a technique to encapsulate IP datagram within IP datagrams, which allows datagrams destined for one IP address to be wrapped and redirected to another IP address. IP encapsulation is now commonly used in Extranet, Mobile-IP, IP-Multicast, tunneled host or network.

Design Pattern

hassan4u — Sat, 08 Jan 2011 16:05:51 +0000

In software engineering, the design pattern is a solution to commonly occurring problem in the software design. A design pattern isn’t a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations.

Design patterns can speed up the development process by providing tested, proven development paradigms. Effective software design requires considering issues that may not become visible until later in the implementation. Reusing design patterns helps to prevent subtle issues that can cause major problems and improves code readability for coders and architects familiar with the patterns.

The Gang of Four (GoF) patterns are generally considered the foundation for all other patterns. They are categorized in three groups: Creational, Structural, and Behavioral

Creational Design Pattern

This pattern deals with class instantiation only. This is further divided in to class creation and object creation patterns. The class creation pattern deals with proper use of inheritance where as object creational pattern use delegation to do the job.

Abstract Factory:

Provide an interface for creating families of related or dependent objects without specifying their concrete classes. E.g. stamp of automobile parts

Builder Design Pattern:

Separate the construction of a complex object from its representation so that the same construction process can create different representations. E.g. Fast food chain (kids meal and adult meal). Decide if a common input and many possible representations (or outputs) is the problem at hand.

Factory Method:

Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

Object Pool:

Object pooling can offer a significant performance boost; it is most effective in situations where the cost of initializing a class instance is high, the rate of instantiation of a class is high, and the number of instantiations in use at any one time is low.

Prototype Design Pattern:

Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.

Singleton Pattern:

Ensure a class has only one instance, and provide a global point of access to it

Encapsulated “just-in-time initialization” or “initialization on first use”.

Structural Design Patterns:

The design pattern is related to class and object composition. Structural object-patterns define ways to compose objects to obtain new functionality.

Adapter Design Pattern:

Convert the interface of a class into another interface clients expect. Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces. Shape > Ractangle > Legacy Ractangle

Bridge Design Pattern:

Decouple an abstraction from its implementation so that the two can vary independently.

Publish interface in an inheritance hierarchy, and bury implementation in its own inheritance hierarchy.

Facade
Provide a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level interface that makes the subsystem easier to use.

Proxy Design Pattern:

Provide a surrogate or placeholder for another object to control access to it.

Use an extra level of indirection to support distributed, controlled, or intelligent access.

Behavioral design pattern:

This design pattern is about class’s object’s communication.

Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.

The C++ and Java standard library abstraction that makes it possible to decouple collection classes and algorithms.

Observer Design Pattern:

Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically. The “View” part of Model-View-Controller.

Critisim:

Some languages do not need design patterns:

The need for patterns results from using computer languages or techniques with insufficient abstraction ability. Under ideal factoring, a concept should not be copied, but merely referenced. But if something is referenced instead of copied, then there is no “pattern” to label and catalog

Lacks formal foundations

The study of design patterns has been excessively ad hoc, and some have argued that the concept sorely needs to be put on a more formal footing.

Leads to inefficient solutions

The idea of a design pattern is an attempt to standardize what are already accepted best practices. In principle this might appear to be beneficial, but in practice it often results in the unnecessary duplication of code. It is almost always a more efficient solution to use a well-factored implementation rather than a “just barely good enough” design pattern.

Ref: http://sourcemaking.com/design_patterns

Demilitarized Zone (DMZ)

hassan4u — Sat, 08 Jan 2011 12:56:49 +0000

DMZ, or demilitarized zone is a physical or logical subnetwork that contains and exposes an organization’s external services to a larger untrusted network, usually the Internet. The term is normally referred to as a DMZ by information technology professionals. It is sometimes referred to as a perimeter network. The purpose of a DMZ is to add an additional layer of security to an organization’s local area network (LAN); an external attacker only has access to equipment in the DMZ, rather than any other part of the network.

Ref: http://en.wikipedia.org/wiki/DMZ_(computing)

Yahoo’s PIG vs Google’s Sawzell

hassan4u — Sat, 08 Jan 2011 09:38:01 +0000

To make effective use of large computing clusters in the analysis of large data sets, it is helpful to restrict the programming model to guarantee high parallelism

Just as Google Sawzall is built on top of MapReduce, Yahoo Pig is built on top of Hadoop (an open source clone of MapReduce that is supported by Yahoo). Both are high level programming languages targeting massively parallel processing across huge clusters.

However, there do appear to be differences in the languages. Sawzall syntax appears heavily influenced by Java or Pascal, where Pig appears to be motivated by an attempt to extend SQL.

Ref: http://glinden.blogspot.com/2007/04/yahoo-pig-and-google-sawzall.html

Mutex vs Semaphore

hassan4u — Thu, 06 Jan 2011 19:01:49 +0000

Mutex – “Mutexes are typically used to serialise access to a section of re-entrant code that cannot be executed concurrently by more than one thread. A mutex object only allows one thread into a controlled section, forcing other threads which attempt to gain access to that section to wait until the first thread has exited from that section.”

Semaphores – “A semaphore restricts the number of simultaneous users of a shared resource up to a maximum number. Threads can request access to the resource (decrementing the semaphore), and can signal that they have finished using the resource (incrementing the semaphore).”

Ref: http://geekswithblogs.net/shahed/archive/2006/06/09/81268.aspx