Software Engineers' Blog

Structural Design Patterns

2010-11-12T20:08:00.002+03:00

In software engineering, structural design patterns are design patterns that ease the design by identifying a simple way to realize relationships between entities.

Examples of Structural Patterns include:

Adapter pattern: 'adapts' one interface for a class into one that a client expects
- Retrofit Interface Pattern^[1]^[2]: An adapter used as a new interface for multiple classes at the same time.
- Adapter pipeline: Use multiple adapters for debugging purposes.^[3]
Aggregate pattern: a version of the Composite pattern with methods for aggregation of children
Bridge pattern: decouple an abstraction from its implementation so that the two can vary independently
- Tombstone: An intermediate "lookup" object contains the real location of an object.^[4]
Composite pattern: a tree structure of objects where every object has the same interface
Decorator pattern: add additional functionality to a class at runtime where subclassing would result in an exponential rise of new classes
Extensibility pattern: aka. Framework - hide complex code behind a simple interface
Facade pattern: create a simplified interface of an existing interface to ease usage for common tasks
Flyweight pattern: a high quantity of objects share a common properties object to save space
Proxy pattern: a class functioning as an interface to another thing
Pipes and filters: a chain of processes where the output of each process is the input of the next
Private class data pattern: restrict accessor/mutator access

Introduction To Hive Hadoop

2010-10-23T14:39:00.003+03:00

Hive is a powerful data warehousing application built on top of Hadoop which allows you to use SQL to access your data. This lecture will give an overview of Hive and the query language. This lecture includes a work-along exercise. The next video is a screencast of a user performing this exercise.

Cloudera Hadoop Training: Introduction to Hive from Cloudera on Vimeo.

Google URL Shortener - goo.gl

2010-10-15T16:17:00.000+03:00

Today, I have just used the Google url shortener named "goo.gl". Like other Google products, it has a very simple, attractive user interface. The project is still beta, and Google will probably add more features in the future.

Fore more information: vist goo.gl

SOA Principles - Service Abstraction Principle

2010-10-13T20:14:00.001+03:00

In SOA, by keeping specific details hidden, we protect the integrity of the relationship formed between a service and its consumers. Using abstraction, we allow the service business logic and its underlying implementation to evolve over time while continuing to fulfill its duties in relation to what was originally published in the service's contract.

In the real world, abstraction is really existed; For instance, when you want to buy a car, you don’t need to know everything about the engine and its internal components. Why? Because it will confuse you. Hiding unnecessary information from the buyer protects and simplifies the selling process. In SOA, the scenario is quite similar except we don’t have cars to sell, we have services to publish.

Why Service Abstraction is Needed?

The more details we publish in a service contract, the deeper coupling between service and consumers can become. Or in other words, less Abstraction means that the consumers are more awareness of the underlying service logic, technologies, and internal details of the service. Consequently, the service consumers will naturally judge on the service based on the metadata or extra information.

Another reason why Abstraction is required is to empower the service providers the freedom to enhance their services. By abstracting the implementation details from the service contract, the service provider can modify the underline logic without effecting the coupling between the published service and its consumers.

Design Characteristics

Providers hide unnecessary information (underlying technology, logic, internal constrains, etc) from the service consumers. The information altogether is hidden in a particular environment that may be accessed by the internal members of the service's organization.

Requirements

Providers need to spend more time on the design phase to concisely define the interaction requirements and public service constrains. This process can be integrated with a governance methodology.

Types of Metadata

In order to abstract non-essential metadata, we need to classify them first. Generally, there are four types of metadata in service oriented architecture:

Technology metadata
the metadata that declares the implementation technology of the service. Abstracting the technical metadata from the service contract reduces technology-to-contract coupling. An example of technology metadata is the underline implementation technology of the service such as "this service has been built using .Net technology and for implementation we used Visual Studio 2005".

However, some technical metadata are required to be published. For instance, How the service can be invoked? What technology required to invoke the service? Is it SOAP or REST? Publishing these details does not affect the integrity of coupling. It just guides the consumers.

Systematic Logic metadata

The metadata that explains the underline logic and how it maintains its goals and capabilities. The underline design details (such as logging details, algorithms, database drivers, etc) are usually hidden from the service consumer. Without abstracting this metadata, a service consumer can easily become coupled to the low-level implementation of the service. Consequently, the service publisher may not be abile to modify or adjust the internal implementation.

Functional metadata

The metadata that explains the functional scope of the service. A function scope determines service's capabilities that are made publicly available through the service contract. In OOP, API often abstracts and maintains a set of generic functions considered those most likely to be used to clients that may need to develop an application capable of connecting with the product, In SOA, the technical contract is the service API.

Quality of Service metadata

In the field of computer science, the Quality of Service (QaS) term refers to resource reservation control mechanisms rather than the achieved service quality. Similarly, In SOA, it refers to the behavioral, runtime polices, reliability-related information about the service.

Web service policies are a common form of service description document that explains the QaS of the XML service. Depending on the runtime environment and the capabilities of the hosting service provider, the qulity of service metadata may need to be placed in the non-technical service document. or SLA (Service Level Agreement).

Like other metadata, it is a good idea to publish some of the Quality of Service metadata to the service consumer. An example of the Quality of Service metadata is 'the availability of the service' as shown:

WebP, a new image format for the Web

2010-10-09T15:40:00.003+03:00

As part of Google’s initiative to make the web faster, over the past few months we have released a number of tools to help site owners speed up their websites. We launched the Page Speed Firefox extension to evaluate the performance of web pages and to get suggestions on how to improve them, we introduced the Speed Tracer Chrome extension to help identify and fix performance problems in web applications, and we released a set of closure tools to help build rich web applications with fully optimized JavaScript code. While these tools have been incredibly successful in helping developers optimize their sites, as we’ve evaluated our progress, we continue to notice a single component of web pages is consistently responsible for the majority of the latency on pages across the web: images.

Most of the common image formats on the web today were established over a decade ago and are based on technology from around that time. Some engineers at Google decided to figure out if there was a way to further compress lossy images like JPEG to make them load faster, while still preserving quality and resolution. As part of this effort, we are releasing a developer preview of a new image format, WebP, that promises to significantly reduce the byte size of photos on the web, allowing web sites to load faster than before.

Images and photos make up about 65% of the bytes transmitted per web page today. They can significantly slow down a user’s web experience, especially on bandwidth-constrained networks such as a mobile network. Images on the web consist primarily of lossy formats such as JPEG, and to a lesser extent lossless formats such as PNG and GIF. Our team focused on improving compression of the lossy images, which constitute the larger percentage of images on the web today.

To improve on the compression that JPEG provides, we used an image compressor based on the VP8 codec that Google open-sourced in May 2010. We applied the techniques from VP8 video intra frame coding to push the envelope in still image coding. We also adapted a very lightweight container based on RIFF. While this container format contributes a minimal overhead of only 20 bytes per image, it is extensible to allow authors to save meta-data they would like to store.

While the benefits of a VP8 based image format were clear in theory, we needed to test them in the real world. In order to gauge the effectiveness of our efforts, we randomly picked about 1,000,000 images from the web (mostly JPEGs and some PNGs and GIFs) and re-encoded them to WebP without perceptibly compromising visual quality. This resulted in an average 39% reduction in file size. We expect that developers will achieve in practice even better file size reduction with WebP when starting from an uncompressed image.

To help you assess WebP’s performance with other formats, we have shared a selection of open-source and classic images along with file sizes so you can visually compare them on this site. We are also releasing a conversion tool that you can use to convert images to the WebP format. We’re looking forward to working with the browser and web developer community on the WebP spec and on adding native support for WebP. While WebP images can’t be viewed until browsers support the format, we are developing a patch for WebKit to provide native support for WebP in an upcoming release of Google Chrome. We plan to add support for a transparency layer, also known as alpha channel in a future update.

We’re excited to hear feedback from the developer community on our discussion group, so download the conversion tool, try it out on your favorite set of images, and let us know what you think.

Posted by Richard Rabbat, Product Manager

Oracle Exalogic - a New Revolutionary Solution

2010-10-08T23:04:00.004+03:00

I always believed adding layers into information system adds more complexities to the internal infrastructure. Today, Oracle started working on a new revolutionary solution that integrates hardware and middleware together. Named Oracle Exalogic.
Both of layers have been engineered together for maximum performance with minimum set-up and minimum operational cost. It allows different components of a Java application to interact with essentially zero-copy I/O, enabling as much as 12x improvement in handling workloads such as Web requests!! More..

Oracle's Plans for Sun

2009-09-11T11:07:00.003+03:00

Source: http://www.oracle.com/features/suncustomers.html

WS Stack Comparison

2009-08-24T12:30:00.003+03:00

If you don't know which WS stack tools you should use in java, this document will certainly help you.

Introduction to Metro

2009-08-24T12:13:00.000+03:00

Using Excepnsive Technologies - No more!!

2009-08-16T23:29:00.004+03:00

I remember myself two years ago when I was using all new technologies from Oracle to build applications for my company, IraqCom. I have to admit that was inconsequential and I could used some open source tools to save thousands of dollars. I wanna share this lesson with you guys, so I upload Oracle price list to the blog.

Please, check it and think about it before using it. Finally, burn these words into your brain! THERE ARE ALTERNATIVES.

Service and Extension Pattern

2009-08-13T16:52:00.007+03:00

In component-base system, we always try to decouple components from each other. Sometime, decoupling process becomes a little bit expensive. In this article, I will talk about a simple approach that can be used for decoupling components, service and extension point pattern.

Why OOP inheritance should not be used?

Service and extension point pattern is similar to general OOP inheritance, but unlike OOP inheritance, it doesn't tight the components with each other. You usually use this pattern when you have a service-provider scenario. For example, suppose component “A” and “B” are in a small HR application called HRTest, component "A" is a module that displays employee information, and component "B" manages data source providers for the application. Data providers can come from different resources like database, web services, or even normal files. As you can conclude, "A" requires at least one provider in order to display employee information to the end user, and B provides the implementation for A's requirements. Using normal inheritance doesn't give a flexible solution because providers may only be exist at runtime, also more than one components can provide the "A" service interface. For instance, "B" and "C". In addition, for some reasons, "C" may be removed at a certain execution point.

Class A{
.
.
.
public void getData(number empID){
ServiceProvider[] service = getService();
}

public ServiceProvider[] getServices(){
getProviderB(); // Get B data provider
getProviderC(); //Get C data provider
.
.
.
}
}

As the preceding example shown, "A" is tightly dependent on "B" and "C." Because, when a new provider such as "D" is added or an old one is removed, "A" should be adjusted.

In such above scenario, service and extension pattern can be used to solve this issue in the flexible manner.

Service and Extension Pattern:

Service and Extension Pattern is commonly used approach in RCP platforms like NetBeans and Eclipse for sharing objects and providing implementation for extension points. Extension point (sometimes is called Service Interface) is a simple interface that a component can define in order to be implemented by other component, which is called Implementation provider or simply Provider. An extension point can have more than one provider at runtime and both providers and service modules should not know each other. To clear the misconception between them, the figure below shows a general structure of the pattern

As the figure demonstrated, Component “A” defines an extension point which “B”, “C” and “D” implement at runtime. Note, because extension point is used by all modules, it should be shared. Therefore, it is highly recommended to encapsulate it in a separate component creating a new abstract layer between them.

What is next?

In the next post, we will implement this pattern using NetBeans Lookup API.

Thanks for your reading.

IoC Pattern

2009-08-08T02:25:00.004+03:00

Yesterday, I took a glance at IoC pattern. I found implicitly interesting article about this pattern and the most interesting article is from java.net as well as martinfowler.com . I hope you guys like it.

Event-Listener Pattern

2009-08-07T19:43:00.014+03:00

In lossy-couple environment, notification system is essential, because it allows two or more lossy-couple components to communicate and notify each other when an event is triggered. There are several patterns to implement notification system in Java and one of them is event-listener pattern.

In Java, building event-listener components is not easy as Flex or C#. It requires a lot of boilerplate code to implement it. In this article, I will talk about building simple event listener in Java. First I will demonstrate the general algorithm for event listeners then I will implement it in a simple, humble example.

Event-Listener Pattern:

Event-Listener pattern is a simple pattern that can be implemented easily in Java bean class. Actually, it is part of JavaBean conventions. It has been used mainly in J2SE platform, particularly in GUI libraries. This pattern consists of two main parts (Source and Listener):

Source: the source is the Java class for maintaining the event listeners which has previously been registered - It is like a small database . Therefore, the source class has method for registering (add) and unregistering (remove) listeners to the small database. The source also has ability to fire an event.
Listener: As the name refers to, the listener is the Java component that interests in a specific event. When an event is triggered, all listeners interested in the event will get a notification and will execute their own event handler codes. Listeners register for events using the methods defined by the sources of those events.

What is share between these two parts is listener event message! The message is usually interface used to determine event data-type.

Sample:

Now, we are going to write a simple implementation for the pattern, so let's start with the source part.

First of all, we need a simple bean class. I will name it “SourceClass”:

class SourceClass {

}

Then we need a data structure to store the listeners (Remember, the small database). For simplicity, I will use Vector

private Vector listeners = new Vector();

Now, we need two methods, one of them for registering and the other unregistering, they should have JavaBean conventional style. The method used to register a listener in the vector must use the prefix “add”, and the other one, must start with the prefix “remove”. Both of them should follow by the event type and must end with the postfix “Listener”. In addition, they should have an argument with event data-type

public void addTestEventListener(TestEvent l) {
listeners.addElement(l);
}

public void removeTestEventListener(TestEvent l) {
listeners.removeElement(l);
}

As the preceding example depicts, the two methods manage the listeners which interest in "TestEvent" Event.

For simplicity, a simple fire method will be added to notify all registered listeners

public void fire() {
Vector temp = (Vector) listeners.clone();

for (int i=0; i > l.size(); i++) {
TestEventListener listeners = (TestEventListener) temp.elementAt(i);
listener.eventHandler ();
}
}

Now, let's define our event, which simply extends EventListener interface in the Java util package

public interface TestEvent extends java.util.EventListener {

void eventHandler();
}

So as you see, the event is nothing than a simple, share interface between the source and listeners.

Finally, we need a simple listener which listens to our TestEvent. Remember, listener can be any class you want. The only thing is required to become a listener is creating a SourceClass and adding the event (TestEvent).

.
.
.
SourceClass c = new SourceClass();
TestEvent e = new TestEvent(){
void eventHandler(){
//Do something
}
}
c.addTestEventListener(e);

c.fire();

As the codes shown above, SourceClass and TestEvent objects have been created. of course, we have to resolve all abstract methods in TestEventListener interface and the last not the least, we add the later object to the source.

when the source fires the TestEvent, listeners gets a notification and will execute their event handler code.

Conclusion:

Event-Listener Pattern provides simple notification system for Java components. The pattern has two main parts (Source and Listener). The source stores all listeners, and the listeners listen to particular event, which is simply the message or notification that transports from source to listeners.

Further Reading:

Google Toolbar Platform

2009-06-16T21:15:00.002+03:00

Now, Thanks to Google Toolbar, you can create a custom button that can run almost in every well-known browser.

For more information, click here.

Adobe Firework + Flash Catalyst

2009-06-14T18:14:00.002+03:00

This demonstration demonstrates how Adobe Firework can be used in Flash Catalyst

Interesting Article: Systems Architecture

2009-06-14T17:49:00.003+03:00

A very unique article talks about Systems Architecture in general, and SOA in specific. Furthermore, It explains the evolution in Software Architecture.

Excellent job Duane Nickul.

Linux Yahoo Messanger + Voice + Webcam

2009-06-13T18:18:00.008+03:00

Many Linux users have got some problems with Yahoo messenger. Since official release does not provide new feature like VOIP + Webcam. Fortunately, You can install unofficial version called (Gyachi) which supports almost all the features including: photo sharing, voice chat, file sharing, group chat, my yahoo page , etc.

To setup, choose and download your appropriate package:

Ubuntu Jaunty packages:
gyachi_1.1.70-1~jaunty_i386.deb
gyachi_1.1.70-1~jaunty_amd64.deb

Ubuntu Intrepid packages:
gyachi_1.1.70-1~intrepid_i386.deb

gyachi_1.1.70-1~intrepid_amd64.deb

Ubuntu Hardy packages:

https://launchpad.net/%7Eloell/+arch…ntu11_i386.deb

Or visit the official website ; click here.

Check Out OTN Virtual Developer Day Records

2009-06-11T14:42:00.003+03:00

Don't miss these fantasting demonstrations from OTN. Click here

JDeveloper's memory Problems

2009-06-11T14:33:00.005+03:00

I've always got some overhead memory problems since JDeveloper 10g. Finally, I have found a new way to reduce JDeveloper's consuming memory. Check out this link

Adobe Flash Catalyst Changes Everything

2009-06-10T12:45:00.008+03:00

Adobe Flash Catalyst is a new tool which has been released recently by Adobe. It bridges the Flex and Flash world into one interaction tool. It connect CS 4 tools with each other, and off course it provides a very convenient way to connect developers and designers together. Therefor, now, designers can make GUI in Adobe Photoshop or Illustrator, then transform their artwork into functional user interface. Furthermore, you can create interactive prototype, which is quite important in development life cycle.

Anther thing I want to mention, unlike Flex, Flash Catalyst do not require learning any new language, it has an interactive interface, and it makes sure your creative vision is perfectly expressed.

Anyhow,I hope everyone will try it. You can download from adobe lab website or click here.

Introduction Demo:

Further Reading:

When Should I use REST?

2009-05-29T11:51:00.002+03:00

It is common that REST is one of the best approach that we can use to design & develop a new highly scalable Web application. However, This approach may be a bit tougher when you are working on an extension to an existing enterprise application, or on an integration project relying in whole or in part on existing infrastructure. Eric Newcomer wrote an interesting article about this subject. The article can be found here.

The future of Oracle/Sun

2009-05-29T11:45:00.001+03:00

Three days ago, the news came out that Oracle is buying Sun Microsystems. The Oracle-Sun deal came little more than two weeks after I.B.M. had ended its talks with Sun. This deal shocked many developer and bring a lot of questions and concerns. What is next? What will happen in the future? In this post, in my opinion, I will answer several controversial questions.

The future of Glassfish

To start with, many java developers believe that Glassfish AS is one of the products which is going to be killed by Oracle. However, Let thing about this again, I believe Oracle will use Glassfish to provide new level of products for small & medium-size companies. This new level will consist of MySQL, Glassfish, OpenESB… etc .They will definitely try to attack new level of customers, because current Oracle web stack solution is heavy, expensive and not affordable for mid-scale companies. Therefore, oracle will provide support and easy migration between the solutions.

Another thing I want to mention it, Glassfish is one the most well engineered, fast, and up to date application server available, So Oracle will certainly uses glassfish's code to improve Oracle AS' code.

Finally, Oracle will keep this path open for as long as it wants to attract paid customers and avoid customers making a switch in favor of the JBoss stack.

What about Netbeans IDE?

Will, NetBeans is not only an IDE but it is an RCP, I am sure that NetBeans will have a massive impact on the other oracle products, including JDeveloper. I believe NetBeans is going to provide support for ADF framework and JDeveloper will be killded in the future, just like Oracle forum and Oracle report, because NetBeans IDE has a huge and vibrant community which can not simply be ignored by Oracle.

On the other hand, NetBeans IDE is the core for all of Sun's products. It has connection will OpenSolaris, DTrace and ends with JavaFX development. Oracle can not simply ignores these connections and kill the IDE.

And finally, NetBeans used to be the first IDE which supported the latest specifications, Oracle will keep this opportunity and continue providing bleeding edge functionality both in the deployment and server-side front by pushing GlassFish development forward and also in continuing to support the development of the NetBeans IDE and platform.

What about Star/Openoffice?

As the second largest software company in the world, there is at least one thing that Oracle has NOT had yet that their primary competitor has and that is an office automation suite used by students, grandmas, and enterprises worldwide. The ability to have your name in front of millions of users is a powerful tool particularly when they can download it for free and run it on Windows, MacOS, Linux distros and Solaris. I think we know that Larry is not a great friend of Microsoft and this will give him one more thing to poke in their eye.

Finally, what is going to happen to JavaFX?

The upcoming land grab for rich internet applications (RIAs) will be a fierce competition between Microsoft, Adobe and Oracle with Sun's JavaFX. JavaFX provides an advanced tool with proven security and programming model to deploy RIAs on billions of devices over the network. Its open source status will ensure a broad developer acceptance and diverse contributions from industry, academia and government. In the fight for "eyeballs" JavaFX will provide Oracle with a significant competitive advantage in function as well as wide device support.

Introduction To REST

2009-05-07T11:50:00.000+03:00

I found this YouTube presentation very useful.

Add Java Magazines Widget to your website

2009-05-02T11:49:00.000+03:00

Finally, I finished designing and building a new widget, Java Magazine. The widget has a very simple interactive interface which allows the end user to browse and navigate through the latest Java Magazine. Be free to embed this widget to your blog, web site, dashboard....etc.

the Widget's Code:


<script type="text/javascript" src="http://cdn.widgetserver.com/syndication/subscriber/InsertWidget.js"></script><script>if (WIDGETBOX) WIDGETBOX.renderWidget('6adc2f17-c036-4cac-bfb1-26a0e1a2d298');</script><noscript>Get the <a href="http://www.widgetbox.com/widget/3ba73d0f-c85d-4d73-8b61-34b5a8bc4078">Java Magazines</a> widget and many other <a href="http://www.widgetbox.com/">great free widgets</a> at <a href="http://www.widgetbox.com">Widgetbox</a>!</noscript>

Java Magazinesgreat free widgetsWidgetbox

Java is like Sex!!!

2009-04-28T11:48:00.000+03:00

because:

One mistake and you have to support it for the rest of your life. (Michael Sinz)
Working with communities is more productive.
you will get a headache if you don't use it for a day. (yakkoh)
Once you get started, you’ll only stop because you’re exhausted.
It takes another experienced person to really appreciate what you’re doing.
Conversely, there’s some odd people who pride themselves on their lack of experience.
You can do it for money or for fun.
If you spend more time doing it than watching TV, people think you’re some kind of freak.
It’s not really an appropriate topic for dinner conversation.
There’s not enough taught about it in public school.
It doesn’t make any sense at all if you try to explain it in strictly clinical terms.
Some people are just naturally good.
But some people will never realize how bad they are, and you’re wasting your time trying to tell them.
There are a few weirdos with bizarre practices nobody really is comfortable with.
One little thing going wrong can ruin everything.
It’s a great way to spend a lunch break.
Everyone acts like they’re the first person to come up with a new technique.
Everyone who’s done it pokes fun at those who haven’t.
Beginners do a lot of clumsy fumbling about.
You’ll miss it if it’s been a while.
There’s always someone willing to write about the only right way to do things.
It doesn’t go so well when you’re drunk, but you’re more likely to do it.
Sometimes it’s fun to use expensive toys.
Other people just get in the way.

extended from www.push.cx