Friday, 31 October 2014

CORBA Services

The Common Object Request Broker Architecture (CORBA) is a standard defined by the Object Management Group (OMG) designed to facilitate the communication of systems that are deployed on diverse platforms. CORBA enables collaboration between systems on different operating systems, programming languages, and computing hardware.

Another important part of the CORBA standard is the definition of a set of distributed services to support the integration and inter operation of distributed objects. The services, known as CORBA Services or COS, are defined on top of the ORB. That is, they are defined as standard CORBA objects with IDL interfaces. As such, the services are sometimes referred to as "Object Services”. There are several CORBA services. Here is a one line description of most of the services:

Naming Service
-allows clients to find objects based on names.
- defines how CORBA objects can have friendly symbolic names.
Trading Service
-allows clients to find objects based on their properties.
- supports the finding of CORBA objects based on properties describing the service offered by the object.
Object Life Cycle Service
-defines how CORBA objects are created, removed, moved, and copied.
Events Service
-decouples the communication between distributed objects.
Relationships Service
- provides arbitrary typed n-ary relationships between CORBA objects.
Transactions Service
- coordinates atomic access to CORBA objects
Externalization Service
-coordinates the transformation of CORBA objects to and from external media.
Concurrency Control Service
- provides a locking service for CORBA objects in order to ensure serializable access.
Property Service
- supports the association of name-value pairs with CORBA objects.
Query Service
- supports queries on objects.


Assalamualaikum and good evening to everyone. Let’s see comparison between RMI and CORBA

RMI (Remote Method Invocation)

CORBA (Common Object Request Broker Architecture)
RMI is a Java-centric distributed object system. The only way currently to integrate code written in other languages into a RMI system is to use the Java native-code interface to link a remote object implementation in Java to C or C++ code. The native-code interface in Java is complicated, and can quickly lead to fragile or difficult-to-maintain code.

RMI, as a Java-centric system, inherits all of the benefits of Java. An RMI system is immediately cross-platform; any subsystem of the distributed system can be relocated to any host that has a Java virtual machine handy. Also, the virtual machine architecture of Java allows us to do some rather interesting things in an RMI system that just aren't possible in CORBA.

For example, using RMI and the object serialization in the java.iopackage, we can implement an agent-based system where clients subclass and specialize an Agent interface, set the operating parameter values for the agent, and then send the object in its entirety to a remote "sandbox" server, where the object will act in our name to negotiate on some issue (airline ticket prices, etc.). The remote server only knows that each agent has to implement an agreed-upon interface, but doesn't know anything about how each agent is implemented, even though the agent is running on the server itself.

The Java virtual machine architecture is a disadvantage here, since an additional interpretation layer is added to the processing of instructions. The Java just-in-time compilers (JIT) are capable of generating native instructions from Java bytecodes, but there is still an additional piece of overhead in running each piece of Java code. If we know that migrating system elements around the network is not necessary, then natively compiled Java code can be permanently installed, but by doing this we're sacrificing the critical "run everywhere" aspect of Java.

Relatively speaking, RMI can be easier to master, especially for experienced Java programmers, than CORBA. CORBA is a rich, extensive family of standards and interfaces, and delving into the details of these interfaces is sometimes overkill for the task at hand.

CORBA is designed to be language-independent. Object interfaces are specified in a language that is independent of the actual implementation language. This interface description can then be compiled into whatever implementation language suits the job and the environment.

In CORBA, objects can never really leave their implementation hosts; they can only roam the network in the virtual sense, sending stub references to themselves and to clients. We don't have the option of offloading an object from one host to another.

CORBA doesn't require a commitment to a single implementation language. We can pick and choose how different elements of a distributed system are implemented based on the issues at hand. Legacy systems may dictate our implementation language in some cases (large COBOL systems like to be spoken to in COBOL, for example). Performance may be an issue in other cases. Heavy computational tasks like computational fluid dynamics and finite-element modeling are best written in languages that can be compiled down to native hardware instructions, like C and C++.

If we're using CORBA in these cases, we can take IDL interface definitions for our objects, compile them into COBOL, C, C++, or whatever languages we need at the various nodes in our distributed system. As long as the ORB implementations that we use at each node support a standard inter-ORB protocol like IIOP, the various CORBA objects implemented in various languages can interact with each other just fine.

CORBA is a more mature standard than RMI, and has had time to gain richer implementations. The CORBA standard is a fairly comprehensive one in terms of distributed objects, and there are CORBA implementations out there that provide many more services and distribution options than RMI or Java. The CORBA Services specifications, for example, include comprehensive high-level interfaces for naming, security, and transaction services.

For the conclusion, which is better? CORBA or RMI? It is depends on you. If you're looking at a system that you're building from scratch, with no hooks to legacy systems and fairly mainstream requirements in terms of performance and other language features, then RMI may be the most effective and efficient tool for you to use. On the other hand, if you're linking your distributed system to legacy services implemented in other languages, or if there is the possibility that subsystems of your application will need to migrate to other languages in the future, or if your system depends strongly on services that are available in CORBA and not in RMI, or if critical subsystems have highly-specialized requirements that Java can't meet, then CORBA may be your best bet.

Source :

Parallel Computing as a Carrier

Assalamualaikum and a very good day to all. 

Based on the research in UK, we can analyse that parallel computing is one of the demand carrier there.

The diagram above shows the statistics of the Parallel Computing Job Demand Trend. We can conclude that, the highest numbers of demand are between Jan 2007 and Jan 2008. What are the criteria that we need to fulfil their requirement?
From NVIDIA web page, the requirement are listed as below :
-A good degree from a leading university in an engineering or computer science related discipline (BS; MS or PhD preferred)
- Strong knowledge of C/C++ and/or Fortran.
- Strong knowledge of programming techniques and algorithms.
- Strong mathematical fundamentals, including linear algebra and numerical methods.
- Experience with parallel programming, ideally CUDA C/C++ and OpenACC.
- Good communication and organization skills, with a logical approach to problem solving, good time management and task prioritization skills.

But, how parallel computing runs their job? Here are two examples how they run the parallel computing.

Based on the figure above, a single instance of single application by a basic task runs or MPI (Message Passing Interface) typically runs concurrently run on multiple cores with communication occurring between the process.

Numbering the task in order.  All the task musk be complete first before start with another tasks.  Grouping tasks to specify whether dependent tasks run if parent task fails. By default, the property is not set, in which case all dependent tasks continue to run even if some of the parent tasks fail or get cancel. If you set this property to true, all dependent tasks fail upon the failure of any parent tasks.

Source from :

Wednesday, 29 October 2014

Wireless Security Guidelines

when online using wireless, attackers can steal the password or install the malware codes into
the network. User can avoid this type of risk by following some guidelines.
Guidelines of the wireless security include:

-Limit  the  strength of  the  wireless  network 
so  it  cannot  be  detected  outside  the  bounds  of your home . Anyone with a wireless-enabled computer within range of your wireless access point can hop a free ride on the internet over your wireless connection. The typical indoor broadcast range ofan access point is 150 – 300 feet.  So, ifyour neighborhood is closely settled, or if you
live in an apartment or condominium, failure to secure your wireless network could potentially
open your internet connection to a surprising number of users.

-Turn off Service Set Identifier (SSID) broadcasting. So other people around the range cant detect or saw your SSID.
-Choose  Wi-Fi  Protected  Access  pre shared key(PSK) instead  of  WPA  which  can  be  hacked  into  using  special

-The encryption key must be changed often .

-Change your wireless network's ID. Your network name is also known as a  (SSID) . When you rename your network, you should choose a name that won’t be easily
guessed by others.

-Changing the administrator’s passwords as well as the usernames of the wireless network devices
such as access points . Be sure to change your administrator password to one that is long,
contains nonalphanumeric characters (such as #, $, and &), and does not contain personal information (such as your birth date).

-Disabling SSID broadcast
A Windows XP computer which has a wireless card installed will automatically go into detect mode if it is turned on; if it receives a beacon packet, it will use the SSID information to attempt to set up a connection to that access point. Although this makes it very easy to set up a wireless network, it also means that anyone with a wireless card could connect to the access point. If the system is reconfigured into ‘Closed Mode’, then the access point no longer broadcasts beacon packets. In this mode, the SSID information has to be entered into the configuration of the wireless card so it can send the necessary connection request to the wireless access point and establish a connection

-Ensuring that the router firewall protection is enabled

-Positioning router or access point properly so that there will be no leakage of this wireless signals

 -Turning off the identifier broadcasting mechanism in the wireless routers

 -Checking whether the wireless devices are configured properly by the IT department
Your internet service provider may provide information about securing your home wireless
network. Check the customer support area of your provider’s web site or contact your provider’s
customer support group.

 -Checking the wireless devices for configuration or setup problems regularly


       Assalamualaikum and hye to everybody.. This week we have learn about CORBA. First question in my mind, what is CORBA? CORBA stand for what? Is it coding? Programming?!! But now, my question was answered. Thanks for all who shared about CORBA (Common Object Request Broker Architecture) in this blog. 
        So, now I would like to share about little description of CORBA exampleThis example only illustrate the basic tasks in building a CORBA distributed application by using Java IDL. As usual, command "HELLO WORLD" is common use in any languages. Therefore, you will build the classic Hello World program as a distributed application. This program has single operation which it returns a string to be printed. 

      The way this program was running are the client invokes the sayHello method of the HelloServer. Then, the ORB (Object Request Broker) transfers previously invocation to the servant object registered for IDL interface. Now, servant's sayHello method runs, which returning a Java String. ORB transfers that String back to the client. Lastly, the clients will prints the value of the String.

How to configure Raspberry Pi ?
Before semester break, I just get my raspberry pi that I bought from En Azrul. I’m tried to configure with my friend, En Khairil Hafiz from UTM. We are successfully configuring raspberry pi by connecting to a television. Let’s take a look what have we done.

First of all, you need several things to make your raspberry pi successful functioning. There are:

  1. Keyboard
  2. Mouse
  3. Cable HDMI
  4. Cable Ethernet (cable cat 6) or cat 5
  5. Raspberry pi charger
  6. Raspberry Pi & SD card
  7. Monitor/television
  8. Modem
Step 1: Insert SD Card into a laptop.

Step 2: : Download Raspberry Pi software at  select                              NOOBS and download ZIP.

Step 3:  Download the formatting tool at and select                              download at the left of the page. After that, select SD Formatter 4.0 for Windows  Download.

       Step 4:  Format the SD card. Let’s look my video.


1.    Step 5 : Save and Extract Files of NOOBS  in SD Card

Step 6: Insert SD card into Raspberry Pi. After that, connect the  mouse, keyboard,                                Ethernet cable(cat  6) , HDMI cable and charger. Let’s look my video.


Step 7: On the television, the scene will display NOOB v1.3.10 setup option.                                  

                                    ChooseRaspian[RECOMMENDED] and click Install (i).

after click install

Choose Expand Filesystem, enter < Finish>.  After that enter <Yes>.

Step 8: The raspberry pi will request raspberry pi login and the password.

I get this information from google and it's workThe login and the password are:

raspberry login: pi
Password: raspberry

Step 9:  After you successful login. It will display this:

The command for open the raspberry pi is startx


My siblings very happy to play a game in raspberry pi.

Step 10: How to shutdown Raspberry pi?

Press shutdown button on the right.

It will display this:

Enter a command sudo shutdown –h now

You are logout now.Done. Thanks for reading.Have a fun with raspberry Pi.

Moore's Law Inspires Intel Innovation

Intel co-founder Gordon Moore is a visionary. Moore's Law states that the number of transistors on a chip will double approximately in every two years.

Intel, which maintained this pace for decades, uses this golden rule as both a guiding principle and a springboard for technological advancement, driving the expansion of functions on a chip at a lower cost per function and lower power per transistor, by shrinking feature sizes while introducing new materials and transistor structures. The announcement of the historic Intel® 22nm 3-D tri-gate transistor technology assures us that the promise of Moore's Law will continue to be fulfilled.

What Moore's Law means to you

Moore's Law is the foundation for exciting new technological capabilities and improved energy efficiency. The most important thing in the semiconductor industry is what delivers to the end user.

Advances in process technology and reductions in cost make computing devices accessible to an ever-increasing number of people worldwide, empowering innovations across the computing continuum-from the smallest handheld devices to the largest cloud-based servers.


What is CORBA?

CORBA or Common Object Request Broker Architecture is an industry standard which introduced by Object Management Group (a consortium consist of 700 companies and organizations) to aid in distributed objects programming. The CORBA provided in a standard programming language, such as the Java or C++. CORBA is composed of major components: ORB, IDL, dynamic invocation interface (DII), dynamic skeleton interface (DSI), interface repositories (IR), and object adapters (OA).

1. ORB (Object Request Broker) ,the heart of CORBA is the distributed service that find the object implementation for the request, prepare the object implementation to receive the request and communicates the data making up the request. Client can use the same request mechanism and the CORBA object regardless of where the object is located. The ORB implements programming language independence for the request. The request which send by the client can be written in different programming language.

CORBA Products:

i)   Java 2 ORB (Sun’s Java 2 SDK)
ii)  VisiBroker for Java (Inprise Corporation. VisiBroker also embedded in
      other products such as Netscape Communicator)
iii) ORBIX (Iona Technologies)
iv) WebSphere (Application server from IBM)
v)   Orbacus (Iona Technologies)

Examples ORBs implementations:
Client- and Implementation-resident ORB
Server-based ORB
System-based ORB
Library-based ORB

2. IDL( Interface Definition Language ) is used to define  an object interface  and types of objects. IDL allows to define the operations and attributes that an object supports. Basic IDL data types such as long, short, string and float. IDL declarations are compiled with an IDL compiler and converted to their associated representations in the target programming languages according to the standard language binding.

3. DII(Dynamic Invocation Interface) allows client applications to use server objects without know the type of those objects at compile time. It allows a client to obtain an instance of a CORBA object and make invocations on that object by dynamically constructing requests. DII uses the interface repository to validate and retrieve the signature of the operation on which a request is made.

4. DSI (Dynamic Skeleton Interface) allows servers to be written without having skeletons, or compile-time knowledge, for the objects being implemented. It support the implementation of gateways between ORBs which utilize different communication protocols.

5. Using IR( Interface Repositories), a client should be able to locate an object that is unknown at compile time, find information about its interface, then build a request to be forwarded through the ORB.

6. OA( Object Adapter ) is the primary way that an object implementation accesses services provided by the ORB such as object reference generation and interpretation, method invocation, security of interactions, and object and implementation activation and

Object adapters are responsible for the following functions:
Generation and interpretation of object references
Method invocation
Security of interactions
Object and implementation activation and deactivation
Mapping object references to the corresponding object implementations
Registration of implementations