viernes, 26 de abril de 2013

What Is The 80/20 Rule?

The principle was suggested by management thinker Joseph M. Juran. It was named after the Italian economist Vilfredo Pareto, who observed that 80% of income in Italy was received by 20% of the Italian population. The assumption is that most of the results in any situation are determined by a small number of causes.

More details about the 80/20 Rule here:
http://www.entrepreneurs-journey.com/397/80-20-rule-pareto-principle/

Nice reading ;)

The golden circle

Reading a Sweet rupture book about agility, by Laurent SARRAZIN, I was forwarded to the "start with why" speach by Simon SINEK. Sharing the video:




Enjoy the ride;)

Tuckman's stages of group development

The Forming – Storming – Norming – Performing model of group development was first proposed by Bruce Tuckman in 1965, who maintained that these phases are all necessary and inevitable in order for the team to grow, to face up to challenges, to tackle problems, to find solutions, to plan work, and to deliver results. This model has become the basis for subsequent models.

miércoles, 20 de marzo de 2013

The Gateway and the Plugin Patterns


To play lego with your applications, think about using the following patterns:

Gateway: An object that encapsulates access to an external system or resource (Patterns of Enterprise Application Architecture, Fowler et al. Addison-Wesley, 2004)

  •  Every gateway eliminate a direct dependency with the business logic implementation and details like protocols, communication means and mechanisms behind the gateway. 
  • Possibility to wrapp methods, to have control about the asynchronous and synchronous character of the API.
  • Extern applications will not access the data model directly, witch can improve security, and increase maintenability  (It reduce coupling between business logic, platform dependent logic and the data model).
  • Depending on the needs of every system the gateway can be unidirectional or bidirectional.
The pattern Plugin: This pattern extends the behavior of a class by allowing extensions to plug into an abstract class that, in turn, plugs into a core class. This creates a new subclass that includes only the capabilities required in the specific context. 
  • The communication with every extern system will use its own gateway. 
  • The integration with every business logic third application is P2P (Point to point). Communications with Webservices can be concentrated by an ESB tool. Where we could plug and play the different gateways
  • The ease of testing, by:
    •  Separting clearly concerns of each gateway, functionaly, facilitating unit testing.
    •  Pluging and playing mocks gateway implementations that simulate the functional purpose of the gateways.

To adequate to a change all you have to do, is to develop the new implementation of your interface contract, and then plug and play.

lunes, 7 de enero de 2013

Divide it to a modular architecture

Recently I have integrated an interesting and challenging project, in which the code is really hard to deal with, the time of builds of some projects is over tow hours in some cases, average number of code line by some classes  is 10 KLOC. Add to this, code generation for Business Object classes, to integrate their logic with different tools and frameworks, so debugging generated code. Combining this with the use of  observers/observable pattern, witch is notifying everywhere that some value has changed.
The situation is really funny, this is legacy code, so what can we do about?

We can do a lot of things, there is too much work in fact.

First of all, let go for the key point, break system into sub-modules meeting the following targets:

  1. The sub-modules should be defined to be functionally significant.
  2. Possibility to make a pluggable system information, meeting more easily, each customer demand and functional needs, according to its budget.
  3. Each sub-module build should take just few mins. This reduce the high build time of the huge projects to a small amount of time of building a concrete a small and functionally significant sub-module we working in.

Reducing time of builds is a key to optimize the time rates cycle of development, build , test , failure, then correction. It also allows having an early feedback of all the quality management platform we have a set in our environment, and therefore having an early interpretation of its reports and taking the right action. (e.g. like detecting and avoiding Sonar violations, increase code coverage, etc.

miércoles, 7 de noviembre de 2012

Eclipse shortcuts


Productivity depends on the way you use the daily tools you have at work. This is list of some short cuts  that surely will help you to increase your productivity if you are an Eclipse user.



Thanks to my present team for writing them on board and sharing knowledge.



viernes, 16 de marzo de 2012

Capabilities of an Architecture



Capabilities of an Architecture are nonfunctional, they are observable, and measurable. The measures of those focus on qualifying the system under analisis, from diferent point of view, including: scalability, manageability, performance, availability, reliability, and security, which are defined in terms of context.

Some research has examined different factors, criterias and induce metrics to evaluate sofware quality, resource utilization and investment utilization, hardware utilization efficiency, reliability, response time, ease of terminal use, content of the database, aggregation of details, human factors, and system accuracy.

This Figure illustrate an interesting sumary:



And this other, it lists and explain some well-known system quality measures:


For more details, is recomanded to check: 
SCEA Sun Certified Enterprise Architect for Java EE , Study Guide Exam 310-051 


Sofware Design Quality

Analizing architectures can be done form different perspectives and views. Certain model characteristics are measured against quality criteria like: complexity, testability, cohesion and stability.


 Objecteering Metrics is a tool that implements a set of metrics, used to evaluate the quality of the models produced. It measures relevant and easy-to-understand characteristics.  In this way, the designer can evaluate the quality of the work carried out, and compare different technical solutions from a quality standpoint.

The project manager and the software quality engineer can thus:

·         evaluate the overall quality of a project
·         find out whether or not the development of different sub-systems is standard
·         observe the evolution of metric values over time, in order to ensure that the quality of the work produced throughout the development process is maintained



Find out More in detail iformation about this tool and the metrics used to ensure producing High Software Quality:

http://support.objecteering.com/objecteering6.1/help/us/metrics/toc.htm

jueves, 16 de febrero de 2012

¿Qué esperan los usuarios de una Web?

1. Conveniencia y facilidad de uso
2. Confianza y credibilidad
3. Contenidos útiles y de valor
4. Agilidad y rapidez
5. Organización y navegabilidad
6. Personalización

viernes, 19 de agosto de 2011

Java reflection

How to test private methods? One solution is using java reflection, here is a utility class defining a static method, wich allows invocation to the private mehods we want to test.

package org.marwan.alephn.test.utilities;

import java.lang.reflect.Method;

/**
* A class with reflection utilities for testing private methods
*/
public class ReflectUtilities
{

/**
* To be used in case of need to test private methods with
* return type, a cast to the type
* @param aClass
* Name of the class witch declares the method to be invoked
* @param instance
* An instance of a aClass
* @param aMethod
* Name of the method to invoke
* @param params
* Class type of the parameter of the method to invoke
* @param args
* Arguments for the method to invoke
* @return Object to be cast to the return type of the method invoked
* @throws Exception
* If error
*/
public static Object invoke(final Class aClass, final Object instance,
final String aMethod, final Class[] params, final Object[] args)
throws Exception
{
Object o = null;
try
{
final Method m = aClass.getDeclaredMethod(aMethod, params);
m.setAccessible(true);
o = m.invoke(instance, args);
}
catch (final Exception e)
{
throw e;
}
return o;
}

}

Good and quick reference to check for java reflection uses: