This is the first article I read on this subject that is actually giving strong, valid points. I totally agree!

Relying on the technical merits of whatever platform is mostly religion. However, considering the surrounding community and environment totally makes sense. If you pick PHP as a language, no matter what you think of it from a technical point of view, you’re going to have to deal with (or even hire) PHP developers, who have been deeply affected by the hacker syndrome. If you pick the .NET platform, you’re going to work with religious people who do not consider anything which is not an official Microsoft BestPractice. If you pick the Java platform, you’re going to deal with framework-ill people who focus more on the infrastructure than the target application. and so on….
Everything is about choice!  So, just consider this when you start your next project, I feel like it’s as important as other technical considerations..

• Be simple to implement (or at least, be simple for simple cases)
• Be machine-parseable (so that intelligent REST clients can be built)
• Be human-readable (so you don’t have to fire up your HTTP sniffer to understand what went wront, when you’re developping a client)
• Follows HTTP semantics, so proxies, caching, etc continues to work correctly

None of the ideas suggested in the article match all of my criteria, so here is the solution I would suggest :

• ALWAYS return the most appropriate HTTP error code whenever an application error happens. Sure, it might not map perfectly, but choose the one that expresses the concept correctly. It is totally absurd to always use 200 error codes, even the SOAP guys have not made that mistake ! Also make sure to use a server-side REST framework that will automatically handle common errors for you (405 for unsupported methods, etc..)
• When the same HTTP error code maps to several application errors, add an ADDITIONAL X-Application-Error-Code : header that provides a simple string allowing to remove ambiguity (choose a simple all-ASCII exception name). This will allow creating simple clients that can easily parse exceptions without too much burden for simple cases
• Add a body that allows a human being (for instance, the developer of a REST client for your service) to instantly understand what went wrong. This can take the form of either a free-form response, or a fully-parseable (XML, JSON, whatever) response body that contains a message field.
• Only implement the fully-parseable response body when your application has matured. Do it smartly, avoid working weeks on your service before even displaying the first feature to your user

I wish I would explain my super-great-idea about achieving this goal, but as usual, Martin Fowler & Eric Evans have thought about it before me, so here’s just the link to the wonderful pattern called Specification.  You could also buy the Domain Driven Design book, as Evans speaks about it in his book.

First of all, dispatching calls to different services based on runtime conditions is something that is needed all the time. The example explained on the code reef might not speak to everybody, though. Example scenarios of every-day use include :

• You need to change the behavior of a payment system depending on the environment. Obviously, you cannot use the real bank service for development, so you need to switch between a DevelopmentPaymentFakeSystem and a RealWorldBankPaymentSystem implementation depending on a runtime condition (the environment on which the application is deployed)
• You need to activate debug features (IE browser check pass-through in development mode, etc)

Obviously, every programming problem can be solved by adding spaghetti code that adds a few conditions here and there in your real services. But the rest of this post assumes that for testability and maintainability reasons, you are implementing the features as different services : the fake payment system, and the real world payment system

The idea suggested by the aforementionned blog post is to use a front-service that will deleguate to the right implementation (real vs fake) based on a runtime condition (deployment). Even though the idea of doing that is brilliant,  I would tend to think that the provided implementation is assuming a broken, half-implemented IoC container.

Indeed, by using a framework such as Spring :

• The Spring container can directly be used as a service locator (just implement ApplicationContextAware, and spring will inject you the service locator). So, no need to create your own implementation of the container (you could always implement ApplicationContextAware later if you need to switch to a different container, as this is just an interface)
• There is actually no need to use the IoC container as a service locator: the dispatcher service can be declared in the IoC container and one can inject it the different implementations using the IoC mechanisms. This can be accomplished using several techniques : name-based wiring (or the @Autowired annotation coupled with @Qualifier), tag-based wiring (you can now tag implementations based on some logical semantic, and then use @Autowired complemented with @Qualifier to get the right instance), or you can just have all implementations of a given interface directly injected to you so you can do your runtime logic to determine the right object (once again, the magical  @Autowired annotation is your friend, just declare an array of the given type and @Autowired it! )

Sure, there are advantages of abstracting the container, but sping provides so much goodness that it’s pretty sad to avoid making use of it, or mirroring its features in custom code !

For the sake of explaining my point, let’s consider two types of developers :

• Joe the programmer, who doesn’t care about code quality
• Scott, the more advanced developer, who works as hard as possible to produce good code quality

It’s pretty easy to realize that Joe doesn’t care about agility, scrum, and whatever, as he just works on whatever his hierarchy wants him to work on. Give him scrum, give him waterfall, he just won’t see a difference anyways. Code is about copy-pasting, and google is your friend !

Now, let’s see the case of Scott, the “elite” developer. He wants to focus on code. He likes code, he dreams about code, he wants to refactor, and he will do anything that allows him to produce better code. And usually, he just _hates_ politics. When Scott first heard of agility, what he thought was “yeahhhhhhh great!!! FINALLY something that allows me to just focus on my code”. yeah.. that was a few years ago.

That was true, at least for some time, because agility used to be about good developers trying to find a way to just work.

But now, things have changed. Agile is nearly mainstream, and most developers who claim they do agile development are just instances of Joe() who learnt how to create crappy, unmaintainable tests. The good developers have already moved to the latest bleeding edge methodology which is called “Common Sense Politic-Less Programming (CSPLP)“.  That’s what allows them to get away from the religious debates brought by the scrum and agile masses. (they prefer technical religious debates.. but that’s another problem.. )
Once again, what they want is to produce code, not  debate forever about “how long should a daily scrum last”, “what kind of clown tricks could we do to build a better team”, or “how to teach the monkeys how to produce good code without affecting their ego “. Have you heard of google developers applying Scrum ? Have you heard of Linus torvalds bringing agile to improve Linux ? All of them just don’t care, because they already produce good, working software, that they release iteratively. And they did not need agile for that, they had their skills, and their common sense. It’s the developers who are producing the code, not the methodology ! And the successful companies have understood one thing : “if you hire the good guys, you’re gonna make great things”. It’s as simple as that.
To put it in a nutshell, nobody cares about agile and scrum. While the average joe doesn’t care or hasn’t even heard about it, the elite scott is skilled-enough to apply the CSPLP methodology, which stands for Common Sense Politics-Less Programming.

Teams can take advantage of having small iterations followed by retrospectives in order to progressively get better, smarter, and learn from their errors.

And theoretically eventually, the team will get to a point where its members can efficiently work together, where every team member can produce high quality and maintainable code, where the sky is perfectly blue, and the sun is shining.

Yeah.. eventually, we will live in a perfect world…

However, there is something that bugs me with this approach: by letting the team “auto-organize itself to discover its own solutions to its highly specific issues”, we actually end up having the team re-invent the wheel to solve the always-same problems that every development team faces. Yes, guess what ? At some point, sometime in the future, the team will discover that it needs to write decent OO code, that it needs to have a decent coverage of carefully written tests or executable specifications (TDD, BDD), that the domain needs to be properly externalized from the technical code (DDD), that it needs decent modelling skills, that IoC enhances the testability of their code,that it needs to decouple the code with small modules and services, that junior developers need to be coached by senior ones, and so on…. Or.. the team won’t discover it, because the project will lack money at some point, and everything will need to start from scratch again.. Wao! so productive !

So, the question is.. What can we do to reduce the duration of the learning curve ? How can we make sure new projects can benefit from the experience of previous ones ? That’s exactly the debate we have had with a few guys from Pyxis Technologies (http://www.pyxis-tech.ca).

When dealing with organizational coaching (Scrum, Agile), the idea of imposing engineering practices (XP, DDD, ..) was totally rejected by a few people that had concrete examples of failures. Most developers have a great ego and still haven’t learned enough of programming to just admit they can learn more from others.

So, what are the other ideas that were thrown ? Everyone seemed to agree that most of the problem lies in the beginning of the contract: every Scrum/development contract should start with an initial diagnostic, that states the technical debt accumulated by the team. This can then serve as the basis of an execution plan. Most of the challenge lies in linking the technical recommendations with business objectives, and clearly explaining the value of these engineering practices to the product owner and stake holders.
Once the product owner (PO) agrees with the values and the vision, most of the job is done. The team is supposed to work on the PO’s priorities, and the technical coaching will be seen as a wonderful help to meet the business objectives.

Of course, in order to achieve this, a few things will need to be sorted out such as compiling the list of the best practices that we embrace. But nothing impossible here, I guess.

Is that enough to learn faster ? probabably. Is that enough to learn wayy faster ? probably not ! We will still see crappy code being produced for months (years ?), and projects failing because of that. So, what can we do to DRASTICALLY improve the quality of code that is produced by those teams ?

ACEGI

1. If you use composition, your domain objects don’t have to implement the UserDetails interface, so you don’t have to “pollute” them.

1′. Even if you do not use composition, implementing an interface doesn’t  mean your domain objects are not POJOs anymore. However, having to inherit some base class makes them not POJO, which is not the case with Acegi.

2. There is no concrete provider, but once again, if you wrap your AccountDao (or whatever JPA/Hibernate Dao ), implementing the provider takes 2 or 3 lines of code….

3.  Yes, indeed the documentation is not easy to deal with…

APPFUSE

1. Annotations vs XML debate… I guess it’s a matter of taste.. XML is definitely more powerful, etc, but you don’t generally need this power, and ease of maintenance can be considered as more important that theoretical flexibility…

2. I agree.

For instance… Let’s say you want to display AJAX-pages that will query the server asynchronously for some stuff, and display the result to the user. One of the best alternatives is DWR, so let’s say you use version 2, because it supports annotations, etc..

Now, you want to create AJAX-validation of your forms. You don’t want to reinvent the wheel, so you use something like Struts2, with the ajax theme. Bad luck ! Struts2 seems to work fine with DWR1, but one will have problems with DWR2… How do you solve the issue ? Patching, patching, patching, if you have the time.

The problem is that this kind of headaches constantly happens whenever you use a few frameworks and libraries, which completly kills the productivity… Another real headache  would be the use of Spring 2 + AspectJ + Hibernate to Dependency-inject POJOs… The problem + solution is described on this post…

Another example I came accross would be the incompatibility between some prior ActiveMQ  version (before 4.x was released) and Spring 2.0, whereas everything was working fine in 2.0 RC4… The problem came from Xbean 2.6 which was incompatible with Spring 2.0 final….

And I could post hundreds of framework-headaches … I am not saying frameworks and libraries are bad (otherwise, I wouldn’t use them), but they’re not paradise either…

However, I think we have a deeper problem than just the lack of maven2 package..  Just take a look at the number of jars in Maven2 repository. And this doesn’t take into consideration the jars offered on Java.net repository, or Apache Incubating one.

So, what is the problem exactly ? Well, it is going to be IMPOSSIBLE for Debian to keep up with the crazy and constantly increasing amount of Java jars available. So, instead of trying to re-package Java libraries once again (mainstream developers already have to package them for maven1 and maven2), why not work on some integration between Debian Packages and Maven2 ones ? And when you think a bit about it, Debian has the same problem with PHP PEAR and and Perl CPAN.

Maven2 is a full-blown java package system that expresses dependencies, etc. So, to my opinion, what Debian should do is the following :

• Create a notion of a “soft-depencency”. Basically, this  would mean that any Package can have hard dependencies (the current deb dependencies), and soft dependencies which could be resolved by a soft-dependency subsystem.
• In order to deal with Java, CPAN and PEAR’s case, a soft-dependency could be expressed as prefix:dependency. A soft-dependency manager could register a prefix, and the dependency string would be subsystem-specific.  So, for instance, if I need freemarker, the dependency could be maven2:freemarker/freemarker/2.3.8

Now, the question is whether Debian is ready to accept such a shift in its concept ?

width="200" height="20"
hasText="true"
progressValue="7"
maxProgressValue="10" id="testBar" showOnlyIntegers="true" />

Now, you want to animate it so that it progressively reaches its progressValue. Something like the following will be needed :

function animateProgressBar(progressBarName, targetValue anim) {
dojo.event.connect(
anim,
“onAnimate”,
function(e) {
var bar = dojo.widget.byId(progressBarName);
bar.setProgressValue(targetValue * e.x / 100);
}
);
}

dojo.addOnLoad(
function() {

var anim = new dojo.animation.Animation(
new dojo.math.curves.Line([0], [100])
, 2000);

animateProgressBar(
“stressLevelProgressBar”,
7 ,
anim
)

anim.play();
}
);

And it should be working…

We can probably draw a parallel with the funny quotes about Java I previously cited.

My opinion is that every Java developer is aware that everything he does is far more complex than it should be. However, abstraction is the key foundation of Computer Science, and most people agree that C is a good abstraction over ASM and Java/.Net are good abstractions over C. So, what is the limit of abstraction ? Are frameworks, Design Patterns, Factories and new abstractions all over the place a good thing ?

What is sure is that people who start using frameworks and libraries use even more of them. So, even if it is not a perfect solution, there is something great in that.

Something important for the web development community in this release is the  support for scripting languages. In fact, the trend, that has been started with Java Hotswap, is to create tools that allow Web Frameworks to be more productive for developers.

Indeed, developers are tired of the develop / build / deploy cycle, and would prefer to work with the PHP-like develop / reload in browser development cycle. Well, scripting is a step in that direction, and would allow to :

• Keep the domain layer as strongly-typed POJOs, that are unit-tested and constantly refactored to keep a good design.
• Write the Web Controllers (the C in MVC) in any scripting language (the view being written in any already-existing templating language, such as JSP or Freemarker). This allows rapid development and since the view is hardly reusable anyways, it’s better to throw it away and recreate something from scratch when needed.

Efforts toward that direction have already been started, as relayed by these few blog entries and articles :

• Christian groovin’ with webwork 2
• Groovin’ with Webwork 2
• Groovin’ with Webwork 2 : using Groovy as actions

So, now the next step is to have universal support for that kind of development, and have better IDE support that will allow refactoring both in the scripted controllers and the view (JSP, Freemarker..). In fact, there is currently no way to make sure nothing is broken besides writing functional (Selenium, Canoo Webtest, HttpUnit…) tests.

In any case, I am curious to see one or two examples of these Meta Patterns to truly understand his thoughts.

Not only does it make people more productive by avoiding the need to edit 5 files at the same time (The Java class + the HTML/JSP/Freemarker template is all we should need to edit while creating a web application… Take a look at Tapestry 5 ), but it also shows the validation code at the same place at the code, and thus helps to maintain both.

However, I believe both approaches are not the way to go. We all use the validation features provided by our lovely MVC frameworks because it is handy, but when you think about it, validation should be part of the domain. The domain classes should be intelligent, they should have as much behavior as possible, and validation is one of the thing the domain should provide, in order to maintain integrity. For instance, if a domain layer has 2 User Interfaces (Web, and Swing, let’s say) interacting with it, the validation rules should only be implemented once, in the domain, not twice, because the integrity checks must be centralized.
But the frameworks are not quite there yet :

• Declarative (using annotations, for instance) is built into MVC frameworks and as such, are only tightly integrated to the view, not the domain. So, it requires more efforts to do validation on the domain. (Think of it as Spring MVC or Webwork validation, that automatically returns to the form and repopulates the data in case of an error VS throwing an exception that you have to handle manually)
• Validation defines constraints, and as such, is best expressed declaratively. However, if one wants to check constraints in the domain, it is necessary to either programmatically do it, or use AOP (maybe coupled with Annotations) to do so. However, it is still unclear whether AOP is a good thing to implement domain features. Lots of people tend to think of AOP as a way to implement cross-cutting TECHNICAL concerns, such as security, cache, or transaction demarcation.

Has anyone ever thought about that issue ? Have you implemented (programmatic) domain validation (maybe using Hibernate Validator, which is limited to persisted classes ?) on a real-life project ? What do you think about it ?

Another problem is about designing the domain. For that part, I urge anybody to look at “Domain Driven Design Quickly” or Eric Evan’s Domain Driven Design book.

The problem

As an Internet user, you need to keep track of one account/password pair for each website you use. It is then necessary to choose between having the same password everywhere (the weakest part of the security chain is thus the weakest website…), or maintaining a potentially long document with all the website/password pairs…

As a Software developer, you need to keep track of all the system passwords (.htaccess passwords, database URL/passwords, accounts on the companies’ computers, and so on..).

Finally, as a System Administrator, you need to keep track of all the system’s passwords, which include each application’s password (MySQL root password, SYMPA password, LDAP Manager entry’s password, root passwords on each machine, Apache SSL certificates keys’s protection passwords….). Additionally each administrated (web) application has its own “admin” account with an associated password, and these applications’ configuration files often include passwords for other components of the system (database accounts/passwords, LDAP password, …). Even efforts such as using centralized LDAP authentication result in having some LDAP’s binding account in the configuration files…

Not only it is a mess to administrate, but it is also a very nice way to forget/mess up with permissions and this can result in weak systems that are easily hackable, because of the complexity.

The solutions

The solution to improve the end users experience would require the whole internet to switch to Single Sign On Solutions. Some vendors are pushing centralized SSO solutions, like Microsoft Passport, which is a pretty criticized solution, both technically and ideologically. Others are pushing open, distributed SSO solutions, like OpenID and LID.

Now that everybody is talking about the “Web 2.0″, it is time to think about improving the user’s experience and security, and this implies adopting one of these technologies in a large scale.

Concerning the Software developer’s and System Administrator’s problem, the problem is way more complex. Sure, the total number of accounts and passwords can be limited by using centralized authentication schemes for applications that support it - all should in a perfect world - (You can find more information about using a centralized LDAP repository for Linux/PAM on this page. If you go this way, you will have to find a good, secure distributed/network file system to share /home directories), but the way applications are currently designed does not open the door to an easy solution. Each application/server has a special “admin” mode that gives the user more permissions, and it is common practice to protect that account using a user-defined password.

So, I’d like to know if anyone has ever thought of something nice that could potentially change the world for system administrators and software developers ? One thing I can potentially think of would be a solution where specific roles would be defined and standardized (system administrator, database administrator, ….), and each application would work with the system to validate a set of credentials (and check that the given user has the required role) supplied by the user before giving the permissions. In other terms, this would be some kind of PAM with the addition that system groups would be standardized. And frankly, with the number of applications and needs, I do not really see this as a possible solution.

Another option would be to switch to certificates to authenticate the users. Coupled with well-defined discovery+ storage solutions, there could be some /etc/certificates folder (+ some mechanism to associate certificates with applications roles) containing public keys that applications would lookup in order to validate user credentials. This would imply that each application could somehow challenge the user who would have previously stored his private key on a system that would act as a mediator between each application and him. Humm.. well.. this doesn’t really sound as an easy solution to me…

The goal of hot swapping is to allow the JVM to take new versions of the classes into considerations without reloading the JVM/Application.
Jonas believes it is a bad idea, but I think he refers to the ability of HotSwap to be used for AOP-like byte code instrumentation. Jonas seems to be heavily involved in AOP framework development, so I am not going to contradict any of his claims.

However, I DO believe that HotSwap can be used to improve the developer’s experience. Consider a web application that contains 100 Hibernate classes and takes 20-30 seconds to load. Most of the development time is spent loading and reloading the context, for each slight change in the Controller and View layers. Baiscally, if you want to add some stuff in a web page, you have to

1] Modify the action (Struts/Webwork Action, Spring MVC Controller, or Tapestry Page) to load the data from a database

2] Modify the view (.jsp/.jtl for Spring/Struts/Webwork, .html for Tapestry)

3] Deploy the application (30 seconds)

4] Test it. See that there is an error.

5] Correct the error, re-déploy the application (another 30 seconds)

and so on…

So, one of the solution is to use Jetty to deploy the application (for instance, using the Maven2 Jetty6 Plugin). This allows for hot-redeployment of JSP pages, but does not take the new classes changes into consideration. Jetty + Tapestry 5 is an attractive option for developers since it allows for hot deployment of both the HTML and Java code. This is awesome, except that I believe it should not be the MVC Framework’s job to do all the gory details of detecting new classes, re-loading the new ones, and so on. It is necessary to have a generic solution that will benefit all frameworks without specific support from them.

And this solution is called Java HotSwap. I am looking forward to having IDE support for that, that will allow to forget, once for all, this costly  change-build-redeploy  process.

So, the real solution to all these problems would be to leverage UTF-8 as the default encoding for every application. If communication is necessary with a legacy system that does not support UTF-8, then whatever ISOxxx encoding is acceptable in a small wrapper that translates the stream to a UTF-8 one. In order to accomplish this :

1. Make sure the default locale on all your systems are UTF-8. Recent linux distributions like Ubuntu luckily default to that.
2. When writing or reading anything to a stream, Java (and I believe other languages too) defaults to the default encoding on the system. Do NOT trust this value, and make sure to only use the Reader/Writer constructors (example: OutputStreamWriter provides a few constructors that take the Charset. Use these constructors at ANY COST, and possibly write Jalopy rules that prevent the use of the default ones).

From a more general point of view, it would be desirable to have UTF-8 everywhere : Domain Name System (which stil uses ASCII), SMTP (which reverts to ugly hacks to allow people to write non-ASCII characters), etc…

The internet is an international place, and as such, should not be ASCII-centric. This means that if the standardization organisms (IETF, ..) do not realize this, we are going to see more and more forking such as China’s reform to its DNS, which is obviously a bad thing for the community since it creates more interoperability issues.

As far as I am concerned, I strongly believe that Open Sourcing Java will open the door to more innovation and wider adoption around/of this technology. When it comes to high-level languages, the only truly Free (Libre) option on the linux/*NIX desktop was to use Mono/C# (more and more GNOME applications are written in C#). Adding more competition by releasing Java Open source will most probably lead to better, easier to maintain applications.

Another important point about the GPL’ing of Java is that Java itself will benefit from the change. Look at GCJ, for instance, which tries to get rid of the JVM and directly compile java to machine Code. It is yet to prove whether this approach would actually make Java faster, but in any case, it would help to better integrate Java with the unix-way of doing things, instead of having Java on one side, and the whole OS on the other side. Few to no efforts have actually been done in order to mix high-level languages with the system.  GCJ is currently struggling to implement both the language and classlib aspects of Java. Once the classlib will be released as Open Source software, GCJ developpers will be able to concentrate on the compiler itself, and on the integration of Java with C/C++ code, which will be an incentive for the people who don’t like JVMs to use Java (after all, Java will just be a simpler C++ that provides a decent library by default).

DWR is basically a Remote Method Invocation framework that allows to “export” server-side Java Objects to the javascript-enabled web client thanks to a transparent communication layer that dynamically (at runtime) generates the client stubs. So, in other terms, You have server side Java methods that you want to run from the client. DWR takes these classes/methods and provides you with a javascript file (generated on-the-fly) that provides javascript classes/methods that once called, will handle all the method calls, marshalling/unmarshalling, etc..

DWR does not provide any UI-abstraction layer. In order to create nifty graphics, you have to complement it with another framework like Dojo toolkit, or Script.aculo.us
Since the official documentation isn’t particularly clear on how to get DWR to work with Spring-managed beans and Java5 Annotations, here is a mini-HOWTO that completes it. (Anyone is free to use this HOWTO under any OSI-approved Open Source license). Nothing is easier to understand than a simple example, so we are going to create a Client Side Logger API that logs the events on the server-side thanks to Log4j. (A real-world example should use some abstraction layer like Commons-Logging , and should result in the creation of a backend to some of the popular Javascript logging frameworks, like Log4Javascript, instead of reinventing yet another logging API).

As a sidenote, DWR is part of the typical Bleeding Edge Web-Framework Stack that I wrote about in a previous post. Surely, not everybody uses this Stack, but it gives an idea of what the current trend in the Java world is. The current java world is full of innovation. Every 2 days, a new framework arrives on the scene, and beginners are more and more afraid of the overall complexity of the platform (if we can call this a platform, because it more looks like a set of unrelated  tools that people struggle to use together, in opposition to Microsoft .Net’s stack that we can safely call a “solution” because of the tight integration between the components). Innovation is doublessly a very good thing, and nothing should prevent innovation from happening. However, I believe it is also very important to document the best practices and tools and try to gather the community around a limited set of paradigms and frameworks. It doesn’t make sense to have a different framework for each programmer in this world. And in my humble opinion, using such an RMI-like system for communicating between Java classes and Javascript is definitely one of the best and efficient (from the developers viewpoint) practices around.
Java class

The first step is to create the annotated Java5 class that will be exported to the Javascript client. All exported methods must be annotated thanks to the @RemoteMethod annotation, and the @Create annotation is used at the class level to tell DWR that the class is instantiated using the Spring Framework. The beanName parameter must reflect the name of the bean in Spring’s application context file.

@Create(creator = SpringCreator.class, creatorParams = { @Param(name = “beanName”, value = “clientSideLogger”) })
public class ClientSideLogger {

public static Logger logger = Logger.getLogger(ClientSideLogger.class);

/**
* @param arg0
* @see org.apache.log4j.Category#debug(java.lang.Object)
*/
@RemoteMethod
public void debug(String arg0) {
logger.debug(arg0);
}

/**
* @param arg0
* @see org.apache.log4j.Category#error(java.lang.Object)
*/
@RemoteMethod
public void error(String arg0) {
logger.error(arg0);
}

/**
* @param arg0
* @see org.apache.log4j.Category#fatal(java.lang.Object)
*/
@RemoteMethod
public void fatal(String arg0) {
logger.fatal(arg0);
}

/**
* @param arg0
* @see org.apache.log4j.Category#info(java.lang.Object)
*/
@RemoteMethod
public void info(String arg0) {
logger.info(arg0);
}

/**
* @param arg0
* @see org.apache.log4j.Category#warn(java.lang.Object)
*/
@RemoteMethod
public void warn(String arg0) {
logger.warn(arg0);
}

Spring Configuration

In order to instantiate the ClientSideLogger class with Spring, we can create the following dwr.xml file, that is going to create a “clientSideLogger” singleton :

<?xml version=”1.0″ encoding=”UTF-8″?>
<beans xmlns=”http://www.springframework.org/schema/beans” xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xmlns:aop=”http://www.springframework.org/schema/aop” xmlns:tx=”http://www.springframework.org/schema/tx”
xsi:schemaLocation=”http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd”>

<bean id=”clientSideLogger” class=”fr.cvf.vodoo.ihm.portal.dwr.ClientSideLogger” />

</beans>

Web.xml glue

The next step is to write the usual glue (setup the DWR/Spring servlet, etc…).

In your web.xml, you can add :

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring/dwr.xml</param-value>
</context-param>

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<!– DWR servlet , that should list all annotated classes–>
<servlet>
<servlet-name>dwr-invoker</servlet-name>
<display-name>DWR Servlet</display-name>
<servlet-class>org.directwebremoting.servlet.DwrServlet</servlet-class>
<init-param>
<param-name>debug</param-name>
<param-value>true</param-value>
</init-param>
<init-param>
<param-name>classes</param-name>
<param-value>
package.ClientSideLogger
</param-value>
</init-param>
</servlet>

<servlet-mapping>
<servlet-name>dwr-invoker</servlet-name>
<url-pattern>/dwr/*</url-pattern>
</servlet-mapping>

Javascript Code
The final step is to use the logging using the automagically generated javascript API.

First, make sure the following javascript files are included :

<script type=’text/javascript’ xsrc=’/dwr/interface/ClientSideLogger.js’>
</script>
<script type=’text/javascript’ xsrc=’/dwr/engine.js’></script>
<script type=’text/javascript’ xsrc=’/dwr/util.js’></script>

And you can use the API :

ClientSideLogger.error(”error message”);

That’s all you have to do !

This simple HOWTO explains how to configure Sympa and WWS to run with Apache2 and FastCGI. FastCGI is used instead of CGI because of the performance impact it has. (Basically, CGI forks a new instance of the CGI script wheareas a FastCGI-enabled script runs as a daemon to handle requests, much like a decent system like Java Servlet API.)
Installation

Install the sympa package, and copy the installed apache1 configuration files to apache2 folder

# apt-get install sympa libapache2-mod-fastcgi

# ln -s /etc/sympa/httpd.conf-fcgi /etc/apache2/conf.d/sympa-fcgi

# dpkg-reconfigure -plow sympa

A wizzard will come up, make sure to :

• Use a database if you want to use WWS
• Select “Other” when asked what type of web server you are running
• Tell the wizzard that you want FastCGI enabled

Once this is done, check the /etc/sympa/wwsympa.conf file, and make sure

use_fast_cgi is set to 1

and the last step is to restart apache :

/etc/init.d/apache2 restart

Now, my personal thoughts about mailing-list systems. My impression is that there is no perfect Open Source mailing-list system (however, there are several ones that “do the job”). The characteristics of a good mailing-list system would be, to my opinion :

• Be entirely configurable through a Web UI. Sympa does a pretty good job at this, since most of the settings are tweakable from WWS. However, the UI is pretty ugly (sure, one can tweak the templates, but…)
• Would provide a Mailing-List system as well as a Web forum. To make it simple, something like Google Groups, that also allows to post (and subscribe/unsubscribe orders) via email. It is then up to each subscriber to choose between email and Web.
• Re-uses a well-known templating system ( Smarty in the PHP world, or Freemarker in the Java world, …). Why re-inventing yet another templating language if very good ones already exist ? Having to learn a templating language per web-application is pretty much cumbersome.
• Be extensible : It should provide a decent plugin system, that people can use to provide additional modules without touching a single line of the current base code. Requiring the modification of a 9980-line (cat /usr/lib/cgi-bin/sympa/wwsympa.fcgi | wc -l) perl script is, In my humble opinion, very bad practice. This implies coding against interfaces, and using some kind of IoC framework like the Spring Framework.
• Would be independant of the persistence layer, through the use of a sophisticated persistence engine such as Hibernate. Anyone can then configure it to use his preferred database engine
• Authentication would also be extensible. A security framework such as Acegi could be used so that anyone can easily have the mailing list system authenticate the users against the configured authentication backend. (be it database, system/PAM, Single-Sign-On, etc..). It doesn’t make sense to re-implement every authentication backend in every webapp, since some frameworks already do the job.

Xen does not support using more than 3 virtual interfaces on the guest machines (the so-called DomU). It is stated in the Xen FAQ, and attempting to use more results  in what Ernie Fontes experienced in this post.
The usual trick for having more interfaces in a stand-alone system is to use IP Aliasing. Ubuntu Linux, among others, support IP Aliasing without any problem. However, IP Aliasing seems not to work (according to my tests) for a Xen DomU.

For some reason that I cannot explain nor understand, there is still a way to use more than 3 virtual interfaces in a Xen DomU by using the offical Xen way of adding interfaces, and by using IP Aliasing on top of that. It is weird, but it works :

• using Xen virtual interfaces is limited to 3 interfaces.
• using IP aliasing interfaces makes interfaces that are not pingable from the outside
• BUT using exactly 3 Xen virtual interfaces, and adding more interfaces thanks to IP Aliasing works beautifully….

Here is a quick HOWTO explaining this procedure :

Xen Configuration

Add 3 interfaces for the DomU (you might replace xenbr1 by xenbr0 if your bridge name is the standard one) :

vif = [ ‘bridge=xenbr1′,’bridge=xenbr1′,’bridge=xenbr1′ ]

And you can create your domain using the usual xm create command.

xm create config.cfg

xm console

DomU Network configuration

You can now configure your domain interfaces and the aliases. For the sake of giving a complete example, here is how to achieve that under Debian/Ubuntu :

Let’s say that we want to configure the 216.240.153.78, 216.240.138.247, 216.240.146.76 IPs for, respectively, eth0, eth1 and eth2, and 216.240.134.6 as well as 216.240.128.182 for the 2 aliases eth0:0 and eth0:1.

/etc/network/interfaces

auto eth0
iface eth0 inet static
address 216.240.153.78
netmask 255.255.255.0
gateway 216.240.153.1

auto eth1
iface eth1 inet static
address 216.240.138.247
netmask 255.255.255.0
gateway 216.240.138.1

auto eth2
iface eth2 inet static
address 216.240.146.76
netmask 255.255.255.0
gateway 216.240.146.1

auto eth0:0
iface eth0:0 inet static
address 216.240.134.6
netmask 255.255.255.0
gateway 216.240.134.1

auto eth0:1
iface eth0:1 inet static
address 216.240.128.182
netmask 255.255.255.0
gateway 216.240.128.1

You can now tell the system to reconfigure the network (/etc/init.d/networking restart), and if it still doesn’t work (especially for the aliases), you can restart the DomU (xm reboot domU-name).

Now, if someone has an idea of why this tip works, I am really really interested to know. Because right now, it looks like magical stuff that I’m not even sure of how I discovered

Warning: Error while retrieving hashfile: Byte order is not compatible at ../../lib/Storable.pm (autosplit into ../../lib/auto/Storable/_retrieve.al) line 331, at (eval line 1

This is caused by the fact that awstats/perl caches DNS Entries in a machine-dependant way. Others have experienced the same problems, like on this forum.

The solution is actually quick. Let’s say your stats are in /stats, you can do :

find /stats -name ‘*.hash’ -exec rm {} \;

Apache

The first step is to activate Logging in Apache, so that Awstats has something to analyze. For instance, you can add something similar in your VirtualHost configuration :

ErrorLog /var/log/apache2/sirika.com-error.log
CustomLog /var/log/apache2/sirika.com-access.log combined

Another important thing is to configure a few things for awstats in apache, like where the icons are, and more importantly, to activate CGI-scripts (since AWstats is written in perl…) . This can be done thanks to the following /etc/apache2/conf/awstats.conf :

# This provides worldwide access to everything below the directory
# Security concerns:
# * Raw log processing data is accessible too for everyone
# * The directory is by default writable by the httpd daemon, so if
# any PHP, CGI or other script can be tricked into copying or
# symlinking stuff here, you have a looking glass into your server,
# and if stuff can be uploaded to here, you have a public warez site!

Options None
AllowOverride None
Order allow,deny
Allow from all
# This provides worldwide access to everything below the directory
# Security concerns: none known

Options None
AllowOverride None
Order allow,deny
Allow from all

# This provides worldwide access to everything in the directory
# Security concerns: none known
Alias /awstats-icon/ /usr/share/awstats/icon/

# This (hopefully) enables _all_ CGI scripts in the default directory
# Security concerns: Are you sure _all_ CGI scripts are safe?
ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/

Awstats

The next step is to install awstats, with all the necessary perl modules.. Using several optional modules implies that you have installed them. liburi-perl is useful if you use the “decodeutfkeys” module, even though it is NOT listed as recommended or suggested in the awstats package.

sudo apt-get install awstats libnet-dns-perl libnet-ip-perl libgeo-ipfree-perl liburi-perl libnet-xwhois-perl

Once this is working, it is now necessary to configure awstats, to tell it which logs it should monitor, and where it should write its working files (stats). This is done by creating a file /etc/awstats/awstats.website.conf (replace website by your apache2 virtual host name, for instance, and do NOT forget the .conf !).

sudo cp /etc/awstats/awstats.conf /etc/awstats/awstats.website.conf

Editing this file should be pretty straightforward, since it is well commented. In particular, pay attention to the following entries

LogFile=”/var/log/apache2/sirika.com-access.log”

SiteDomain=”sirika.com”

HostAliases=”www.sirika.com”

DirData=”/srv/data/stats/sirika.com”

LogFile should point to the log file configured in Apache2.

SiteDomain is the main domain name, as configured in Apache2.

HostAliases should list ALL the aliases listed in Apache2’s VirtualHost configuration. Usually, you will want the same domain prefixed with www, (or without the www prefix if is it already specified in the main domain name). This is really annoying, error-prone and not having a global definition of a “virtual host” on the system is one of the issues I pointed in “10 things that still suck under linux“. Virtual hosts and aliases should be defined once, globally. Every single concept/thing should be repeated/configured once, and only once, on a perfect system. Anyways…

DirData should point to an empty directory, whose content will be managed by Awstats.
Cron

Everything is now configured. On a perfect system, the setup would stop now. Awstats could be automagically notified for every change in the logs (awstats could register to a so-called “http access event”, and its internal behaviour could define its policy for updating the stats (update synchronously, update asynchronously when the system is idle, etc..). This is one of the things I pointed out in “10 things that still suck under linux“. However, we’re not there yet, so, we need to run the script every day to update the stats. (yeah, that’s the reality today..)

So, this can be done thanks to the following /etc/cron.daily/awstats (do not forget to chmod +x /etc/cron.daily/awstats after creating it) :

#!/bin/sh

/usr/share/doc/awstats/examples/awstats_updateall.pl -awstatsprog=/usr/lib/cgi-bin/awstats.pl now > /dev/null

This will update all the statistics for all the hosts defined in /etc/awstats/*, on a daily basis. Yes, it’s not as beautiful as having a full-featured event-system for which every application could attach to events generated by others, but it has the merits of working…

Logrotate

What happens when your apache logs get rotated (and possibly gzipped, etc) by logrotate (apt-cache show logrotate for more information), and awstats still hasn’t analyzed the end of the logs that is about to be rotated ?

To avoid this situation, it is necessary to tell logrotate to launch awstats BEFORE rotating the logs. This can be done by adding the following lines to /etc/logrotate.d/apache2 :

prerotate
/etc/cron.daily/awstats
endscript

Permissions

And of course, permissions must be tweaked :

• Since Awstats runs as the web users for viewing stats (CGI-script), the web user needs read access to /srv/data/stats/*
• Additionnally, you may want to provide the “update now” button on your website stats. So, the web user also needs write access to /srv/data/stats/*
• Finally, awstats needs access to the apache2 logs to create the stats. This is not a problem when it is run from a cron script, since it is run as root. But, in the case of “update now”, it runs as the web server, so the web server needs read access to its logs. (the default permissions are 660 with root:adm), so www-data doesn’t have access to its logs

The problem with traditional permissions is that there is no decent way of specifying default permissions. So, we are going to use ACLs for that. You can find more information about them here (Using POSIX ACLs to complement traditional Linux permissions). So, this gives, for instance :

# read write execute access for web user to the stats directories
find /srv/data/stats -type d -exec setfacl -m “g:www-data:rwx” {} \;

# read write execute access for FUTURE stats files for the web users

find /srv/data/stats -type d -exec setfacl -d -m “g:www-data:rwx” {} \;

# read write access to the stats files for the web user
find /srv/data/stats -type f -exec setfacl -d -m “g:www-data:rw-” {} \;

# read only access to the logs directory for the web user
find /var/log/apache2 -type d -exec setfacl -m “g:www-data:r-x” {} \;

# read only access to the logs for the web user, for future files

find /var/log/apache2 -type d -exec setfacl -d -m “g:www-data:r-x” {} \;

# read only access to the apache2 logs for the web user
find /var/log/apache2 -type f -exec setfacl -m “g:www-data:r–” {} \;

And it should work.. The last thing would be to protect access to your logs, if you don’t want your users to see them. This can be done using a .htaccess file, and there are plenty of tutorials on the web that explain how to achieve that.

So, what is the recommended technology stack for developing web applications today ? It looks like nowaday’s buzz goes toward :

• Apache Maven2 for build-management, and managing profiles (development, integration, production) and its set of plugins which ease application development, like Jetty6 plugin, which avoids constantly redeploying wars to tomcat.
• A so-called “lightweight” JEE framework, like the famous Spring Framework, that everybody raaaves about.
• A Object Relational Mapping framework, like Hibernate, or any of the Java Persistence API implementations (Hibernate EntityManager, OpenEJB, or Oracle TopLink)
• An MVC framework, which is either Action/Request Based (The 2 most popular ones being Spring MVC and Webwork2/Struts2 ), or Component Based (The 2 most popular ones being Apache Tapestry and Java Server Faces )
• A security framework like Acegi to handle authentication and authorization.
• In addition, other secondary frameworks are often used, like DWR for transparent AJAX, or the client side Dojo Toolkit Javascript framework.

From a methodology viewpoint, the current hype is about :

• Test-Driven-Development, thanks to some Unit testing frameworks like JUnit+Easymock, and functional-testing framework like Canoo Webtest.
• Inversion Of Control : Each technical (technical or functional) component must be described by an interface, and the inversion of control container - usually Spring - takes care of instantiating the right objects to avoid the need to create hundreds of Factories and Singletons).
• Aspect-Oriented Development (AOP) : User code should not be polluted by cross cutting aspects such as Security, performance, Transaction Management, etc. AOP is what allows to factor out this kind of code into reusable aspects.
• Domain Driven Development (DDD), to design rich domain POJOs. Since designing rich domain objects implies that the objects will be smart and will need to access technical objects like DAOs, and directly accessing the implementations would lower the testability of the application, DDD often means using something similar to Spring’s @Configurable annotation in addition to Spring’s AspectJ integration, to magically dependency-inject domain objects (which cannot be managed by spring, since they can be instantiated everywhere)

From my experience, integrating all these frameworks doesn’t work out-of-the-box. It is often necessary to play with the miscellaneous versions of each framework, and it sometimes causes headaches. Classpath issues and human errors are also a great cause of trouble.

If the proliferation of frameworks continues (and I believe it will) , integrated stacks (like AppFuse, but backed by commercial support) will emerge as a de-facto need for kickstarting developments. How many developers out there actually use the whole IoC/AOP/DDD/TDD fuzz ? By looking at the amount of problems I get by using all these frameworks, I have the feeling that not so many people do ……

A simple example of that, is for instance, the use of Spring AOP declarative Annotation-based (@Transactional) transaction management. Nobody tells you that you cannot use @Transactional on a Spring MVC controller, or that you have to activate CGLib proxying to use @Transactional on Webwork Actions. Sure, once you’ve run into the problem and analyzed the cause, the reasons seem obvious, but I still believe that something needs to be fixed with the integration of all these frameworks. Everything works as expected in isolation, but once you start to deal with dozens of frameworks, problems arise more often, and their cause isn’t always obvious. The access to the right frameworks should be eased to improve the overall quality of applications in the software industry.

However, each subsystem has to be managed and upgraded separately. This means that each subsystem is a (nearly) complete system that must be administrated in its own. Another aspect is User Management, since some users may need to be propagated. An LDAP repository can be used to avoid the ugly NIS-like propagation, but one needs to define a policy regarding how the users are laid-out in the directory and how the directory is used, since not all virtual machines may be accessed by all users… And user management also implies the usual sharing of /home, for which most people use the old and broken (though working ) NFS .
Monitoring is also an important topic in this area : open source monitoring solutions like OpenNMS must be leveraged in order to monitor all the servers. This is another layer of complexity, that isn’t necessarily needed.

So now, what I am wondering about is why all the buzz goes to Xen, and nobody really cares about SELinux (except maybe Red Hat which seems to provide decent SELinux support in its distribution). Ubuntu, in any case, does not seem to make SELinux its priority, as Michael Dolan highlights it.

Sure, Xen and SELinux are not meant to tackle the same problems. Xen is a virtualization layer, whereas SELinux is a security layer. However, the problem, I believe, is that people tend to use Xen to tackle security problems that SELinux could solve without the need of additional systems. Of course, for complex needs, Xen+SELinux could be envisionned, but the philosophy behind virtualization is that the system is dumb from a security perspective, whereas SELinux tries to fix the heart of the problems : making a multi-user system secure.

In fact, why would anyone want to setup of a full-blown virtual server just to run a DNS server, if some security stack could protect the rest of the system from being damaged in the case that the DNS daemon would get hacked ?

Now, the question is : Should you use RAID 5, RAID 50 or something else ? Choosing between simple RAID solutions like RAID 0 vs RAID 1 is pretty easy, and one can easily conclude that RAID 0 is for performance (especially writes), whereas RAID 1 is for security. (even though it helps reads). Please note that RAID 1 is very expensive in disk space…
Now, what about the “standard” RAID 3, 4, 5, 5E, 6, 6E levels, or the “nested” ones such as RAID 0+1, 10, 30, 100, 50, 60 ?

In fact, the right choice depends on your specific needs (which is the lovely sentence everyone will use to avoid giving his opinion).

Now, in practice, my personal opinion on that :

• RAID 3 and RAID 4 are only theoretical RAID levels that nobody actually uses.
• RAID 5E, RAID 6 and RAID 6E are probably very good RAID levels, but the RAID card I use doesn’t support it, so I suspect these levels to be only available in higher-end models. If you are lucky enough to try one of those, I would be happy to hear about the performance.
• Most of the other nested RAID levels either are not supported by hardware cards, or are very expensive to implement. So, if you can spend money for them, their evaluation might be good.

After these considerations, and considering that you want a certain balance between security, performance and price, you might want to compare RAID 5 and RAID 50, which are both good compromises between these concerns.

To put it simply let’s consider you have 8 disks. RAID 5 stripes the data over 7 disks, and uses the 8th one for parity checking, so that it can rebuild the data if one disk fails (this is a little simplistic, since no disk is dedicated to partity and the parity blocks are rotated over the disks, but you get the idea).

RAID 5+0 creates 2 RAID arrays with half of the disks, and creates a RAID 0 array (stripping) on top of that. As a result, it is more costly, since 2 disks are used for parity checking instead of one, but is more robust to failures (2 failures are allowed).

It is often said that RAID 5+0 is more efficient for writes… So I wanted to compare how better it is, if ever it is, on a 3ware 9550SX 8 port SATA II RAID controller with write cache enabled, and 8 SATA 300 GB Maxtor DiamondMax 10
So, the result is a set of informal benchmarks, that are probably not related to the way I am going to use the disk anyways, but that has the merit of drawing quick conclusions :
First of all, using RAID 5

sudo dd if=/dev/sda of=/dev/null bs=1M count=1024
10240+0 records in
10240+0 records out
10737418240 bytes (11 GB) copied, 32.7535 seconds, 328 MB/s

dd if=/dev/zero of=out bs=1M count=10240
10240+0 records in
10240+0 records out
10737418240 bytes (11 GB) copied, 88.8292 seconds, 121 MB/s

dd if=./out of=/dev/null
20971520+0 records in
20971520+0 records out
10737418240 bytes (11 GB) copied, 45.3929 seconds, 237 MB/s

dd if=/dev/zero of=ok bs=1M count=1
500 MB / sec
dd if=ok of=/dev/null
630 MB / s
dd if=/dev/zero of=ok bs=1 count=1
40/43 kB / sec (Yes, KB)

dd if=ok of=/dev/null
0+1 records in
0+1 records out
1 byte (1 B) copied, 1.5e-05 seconds, 66.7 kB/s

dd if=./out of=/dev/null
20971520+0 records in
20971520+0 records out
10737418240 bytes (11 GB) copied, 49.5834 seconds, 217 MB/s

dd if=/dev/zero of=ok bs=1k count=1
44 MB / sec

dd if=ok of=/dev/null
2+0 records in
2+0 records out
1024 bytes (1.0 kB) copied, 1.7e-05 seconds, 60.2 MB/s

rm -f ok ; dd if=/dev/zero of=ok bs=1k count=4
4+0 records in
4+0 records out
4096 bytes (4.1 kB) copied, 3.4e-05 seconds, 120 MB/s
120/ 130 MB /s

rm -f ok ; dd if=/dev/zero of=ok bs=1k count=16
16+0 records in
16+0 records out
16384 bytes (16 kB) copied, 8.4e-05 seconds, 195 MB/s

time ( for (( i=0; i < 100000 ; i++ )) ; do dd if=/dev/zero of=$i.out bs=1k count=1 2> /dev/null; done )

real 10m0.205s
user 1m45.403s
sys 8m2.134s

time ( for (( i=0; i < 100000 ; i++ )) ; do dd if=/dev/zero of=$i.out bs=1 count=1 2> /dev/null; done )

real 3m19.841s
user 1m43.242s
sys 1m34.582s

time ( for (( i=0; i < 100000 ; i++ )) ; do dd if=/dev/zero of=$i.out bs=1 count=1 2> /dev/null; done )

real 10m52.149s
user 1m46.703s
sys 9m4.218s

time ( for (( i=0; i < 1000 ; i++ )) ; do dd if=/dev/zero of=$i.out bs=1
count=1 2> /dev/null; done )

real 0m20.931s
user 0m1.068s
sys 0m3.260s

And now, parts of the results on RAID 50 :

dd if=/dev/sda of=/dev/null bs=1M count=10240
Password:
10240+0 records in
10240+0 records out
10737418240 bytes (11 GB) copied, 40.1916 seconds, 267 MB/s

dd if=/dev/zero of=out bs=1M count=10240
10240+0 records in
10240+0 records out
10737418240 bytes (11 GB) copied, 117.762 seconds, 91.2 MB/s

dd if=/dev/zero of=ok bs=1M count=1
1+0 records in
1+0 records out
1048576 bytes (1.0 MB) copied, 0.085963 seconds, 12.2 MB/s

dd if=ok of=/dev/null
2048+0 records in
2048+0 records out
1048576 bytes (1.0 MB) copied, 0.001741 seconds, 602 MB/s

dd if=/dev/zero of=ok bs=1 count=1
1+0 records in
1+0 records out
1 byte (1 B) copied, 3.5e-05 seconds, 28.6 kB/s
dd if=ok of=/dev/null
0+1 records in
0+1 records out
1 byte (1 B) copied, 1.7e-05 seconds, 58.8 kB/s

dd if=/dev/zero of=ok bs=1k count=1
1+0 records in
1+0 records out
1024 bytes (1.0 kB) copied, 3.4e-05 seconds, 30.1 MB/s

dd if=ok of=/dev/null
2+0 records in
2+0 records out
1024 bytes (1.0 kB) copied, 1.9e-05 seconds, 53.9 MB/s

time ( for (( i=0; i < 1000 ; i++ )) ; do dd if=/dev/zero of=$i.out bs=1M count=1 2> /dev/null; done )

real 0m15.759s
user 0m1.068s
sys 0m3.180s

time ( for (( i=0; i < 100000 ; i++ )) ; do dd if=/dev/zero of=$i.out bs=1k count=1 2> /dev/null; done )

real 9m46.112s
user 1m44.779s
sys 7m59.798s

So, my conclusion (which I repeat, is not rocket science) is that RAID 50 isn’t that much better than RAID 5, and is sometimes actually worse, though more expensive. As a result, my personal choice has been RAID 5.

]]> http://www.dalouche.com/wordpress/2006/11/17/raid-5-vs-raid-50-informal-comparisonbenchmark/feed/ http://www.dalouche.com/wordpress/2006/11/04/funny-quote-java-vs-php/ http://www.dalouche.com/wordpress/2006/11/04/funny-quote-java-vs-php/#comments Sat, 04 Nov 2006 21:25:57 +0000 skoobi Uncategorized http://samokk.is-a-geek.com/wordpress/2006/11/04/funny-quote-java-vs-php/ The  Can Java CMS match PHP ones article contains a funny, yet sadly true, sentence :

Maybe while the Java world was engaged in talking of high end, super techie stuff, with the words ‘enterprise’, ‘transactions’ and ‘SOA ‘embedded in every sentence, the PHP guys actually went out and created a lot of simple yet very useful software.

And we can also cite the following article : Why I hate frameworks which goes in the same direction, and is pretty funny too

]]> http://www.dalouche.com/wordpress/2006/11/04/funny-quote-java-vs-php/feed/ http://www.dalouche.com/wordpress/2006/06/18/designing-java-migration-scripts-for-sqlhibernatejava-persistence-api-data/ http://www.dalouche.com/wordpress/2006/06/18/designing-java-migration-scripts-for-sqlhibernatejava-persistence-api-data/#comments Sun, 18 Jun 2006 19:39:00 +0000 skoobi Uncategorized http://samokk.is-a-geek.com/wordpress/2006/06/18/designing-java-migration-scripts-for-sqlhibernatejava-persistence-api-data/ Every web application needs to load initial data into its production database (settings and domain specific data such as available categories, etc..).

Another concern is the migration of current data to the new schema. Hibernate/JPA makes it easy to create additional fields, but as soon as data migration is needed, it is necessary to have something more robust.

That is my current concern : I want to create a decent import/migration system.

Requirements :

• Versioning : Launching a migration should detect the current state of the database without breaking things if the data is up to date
• Heterogeneity-friendly :  Some data come from  XML, others are plain SQL  scripts,  some are  calculated…. So, the importer system should play well with many kinds of sub-importers.
• Transaction-enabled : if an importer crashes, it must leave the data in the previous state
• Developer-friendly and extensible : it should be easy to add new importers for additional sets of data

I am still unsure about how I should do things, so if anyone has already worked on something similar, I am open to ideas.

In any case, once I work out something nice, I’ll re-post

]]> http://www.dalouche.com/wordpress/2006/06/18/designing-java-migration-scripts-for-sqlhibernatejava-persistence-api-data/feed/ http://www.dalouche.com/wordpress/2006/02/27/ajax-frameworks-comparison/ http://www.dalouche.com/wordpress/2006/02/27/ajax-frameworks-comparison/#comments Mon, 27 Feb 2006 09:04:59 +0000 skoobi Web Development http://samokk.is-a-geek.com/wordpress/2006/02/27/ajax-frameworks-comparison/ Daniel provides a comparison of AJAX frameworks . It is especially useful these days since everyone is starting to develop his own AJAX framework.

Not all frameworks are presented (reasons explained), but it’s a good start. Keep up the good work !

]]> http://www.dalouche.com/wordpress/2006/02/27/ajax-frameworks-comparison/feed/ http://www.dalouche.com/wordpress/2006/02/15/aspect-oriented-programming/ http://www.dalouche.com/wordpress/2006/02/15/aspect-oriented-programming/#comments Wed, 15 Feb 2006 20:47:15 +0000 skoobi Methodologies http://samokk.is-a-geek.com/wordpress/2006/02/15/aspect-oriented-programming/ This very nice article from IBM gives some information about Aspect-Oriented Programming (AOP), and why it is good for programmers.

The author clears the myths and understanding about AOP.

]]> http://www.dalouche.com/wordpress/2006/02/15/aspect-oriented-programming/feed/ http://www.dalouche.com/wordpress/2006/02/12/basic-db4o-integration-with-springnet/ http://www.dalouche.com/wordpress/2006/02/12/basic-db4o-integration-with-springnet/#comments Sun, 12 Feb 2006 17:59:24 +0000 skoobi .NET http://samokk.is-a-geek.com/wordpress/2006/02/12/basic-db4o-integration-with-springnet/ Basic Integration of Db4o with Spring.NET is now done. Nothing has been tested yet, but testing should soon start…

I have created a JIRA issue for this. I hope that this will get integrated and reviewed into Spring.NET.

Content of the issue :

It would be nice to have Spring.NET integrated with db4o.
I have implemented basic integration here :
http://samokk.is-a-geek.com/Projects/Spring.Net/db4o.tar.gz

Nothing has been tested yet.
I’ll post updates to the same address.

The current version supports :
- Db4o Platform Transaction Manager :
- Db4o Template, that supports both ICallback and delegate method.
- Db4oUtils, that provides utilities to create / dispose connections
- IDb4oDataSource / BasicDb4oDataSource : the exact same thing as a Java JDBC DataSource (Abstract Factory), but for Db4o. BasicDb4oDataSource delegate connection creation to 4 concrete IDb4oConnectionParameters :
* FileDb4oConnectionParameters : Direct file access
* MemoryDb4oConnectionParameters : In-memory database
* EmbeddedClientDb4oConnectionParameters : client to an embedded server
* RemoteClientDb4oConnectionParameters : client to a remote server

These classes work with the Spring.Data classes I found in the sandbox. Do not hesitate to add them to CVS, they are licensed under whatever-license suits you (Apache, BSD, LGPL, whatever)

]]> http://www.dalouche.com/wordpress/2006/02/12/basic-db4o-integration-with-springnet/feed/ http://www.dalouche.com/wordpress/2006/02/10/more-details-about-integrating-db4o-with-springnet/ http://www.dalouche.com/wordpress/2006/02/10/more-details-about-integrating-db4o-with-springnet/#comments Sat, 11 Feb 2006 01:53:26 +0000 skoobi .NET http://samokk.is-a-geek.com/wordpress/2006/02/10/more-details-about-integrating-db4o-with-springnet/ After having spent several more hours on the Db4o/Spring.NET integration issue, here are some of my conclusions concerning Spring.NET internals :

Most of the logic for integrating a Data Access/Transaction support technology to Spring.NET is to be implemented inside 3 major entities :

• The PlatformTransactionManager (Db4oPlatformTransationManager) : definitely the main entity on the system, its purpose is to manage the transactions (Commit, Rollback, and Get a (New/Existing) Transaction.
• The Utilities (Db4oUtils) : Its role is mainly to create / dispose connections. However, it does NOT blindly create connections and dispose them. In fact, it must take into account the fact that most applications are multithreaded (e.g. Web Sites), so the releasing a connection must not affect another thread’s connection.
• The Template (Db4oTemplate) : Its role is simply to remove the connection creation/release burden from user code. The template takes care of dealing with Spring.NET internals, threads, synchronization, etc. As a result, the user code just deals with a connection to the database that it can use to perform its tasks.

Let’s see how everything fits together :

• First of all, it is important to realize that connection creation is an important part of the whole system. In fact, in a multi-threaded environment, several concurrent accesses to the database will be necessary. As a result, it is not possible to have code (e.g. Data Access Objects - DAO) keep references to active connections since it woud mess the whole system. To concurrently access the same database at the same time, several threads must use different connections, so data access code should not maintain references to connections.
  As a result, most parts of Spring.NET (Template, etc) will keep a reference to a Factory Object that allows the creation of connections, instead of keeping a reference to a connection directly. This Factory is the DataSource, in the case of Spring Java and IDb4oDataSource in the case of my Db4o to Spring.NET integration.
• The Spring.NET templates (Db4oTemplate) allow the removal of connection references from Data Access Objects. Indeed, when using templates, DAOs provide delegates (implemented as Object callbacks for Spring Java, since delegates (function pointers) do not exist in Java) whose signature is given by the template. The delegate has the connection object passed as a parameter, so the DAO can actually perform its work without having to care about which connection it will work on. Look at Spring (Java) reference manual which gives quite a lot of information about this.
  As a result, all the connection creation/release tasks are handled by the template instead of the user. This is coded once in the template, and avoids unecessary boilerplate code. Basicaly, here is how (roughly) a template Execute method is coded :
• Get a Connection
• Call the delegate provided by the user : delegateMethod(Connection)
• Close the Connection
• However, Connection Creation and Release is a quite complex task. As a result, it is handled by a utilitary class : Db4oUtils. Here is why it is complex :
• Connections used by each Thread should be handled separately. Thread X should not mess with Thread Y’s connection, or it would lead to race conditions.
• It is not possible nor desirable to create a new connection each time a connection is requested. In fact, the connection should be kept until the transaction is Commit’ed or Rollback’ed, and several calls to GetConnection() can happen before, if, for example, several Db4oTemplates are used.
• Sometimes, we do not want to take part in a Transaction, so the case where there is no transaction to synchronize to should also be taken into consideration.
• Additionnally, Exceptions should be converted to Spring.NET exception Hierarchy..
• In order to handle each thread’s connection separately, a TransactionSynchronizationManager is used. Its role is simply to associate resources and give different resource-spaces to each thread.
• The resources that the TransactionSynchronizationManager deals with are not the connections direcltly, but ConnectionHolders. The subtle difference is that the holder maintains a reference to the Connection, but also keeps some information such as a reference count of users of the connection. So, in the case of nested GetConnection() calls, the reference count will indicate that the resource is still used even though a Dispose() will be done after the nested GetConnection().
• The TransactionSynchronizationManager uses an event-based approach with listeners (called Synchronizations to the resources) in order to do the cleanup of the resources; Since the TransactionSynchronizationManager works with all kinds of connections (ADO.NET, Db4o, etc), it cannot understand how it should cleanup resources after a cleanup, so this is the task of a Synchronization that listen to events thrown by the Manager.

Previous issues :

• Adding db4o OO database support for Spring.NET
• Spring.NET and db4o Integration roadmap

]]> http://www.dalouche.com/wordpress/2006/02/10/more-details-about-integrating-db4o-with-springnet/feed/ http://www.dalouche.com/wordpress/2006/02/09/springnet-and-db4o-integration/ http://www.dalouche.com/wordpress/2006/02/09/springnet-and-db4o-integration/#comments Thu, 09 Feb 2006 23:12:23 +0000 skoobi .NET http://samokk.is-a-geek.com/wordpress/2006/02/09/springnet-and-db4o-integration/ As previously stated, I am currently working on Spring.NET and db4o Integration.

This thread deals with some of my questions regarding what’s currently available in db4o that will allow me to do the job.

Here’s the likely roadmap :

• Create an equivalent of the JDBC “Datasource” : a Factory that allows to create connections regardless of their type (embedded, remote, etc). This will help to abstract the connection creation and provide different implementations (Basic, Pooled) of this creation.
• Create a Basic non-pooled implementation of this Db4oSource
• Implement a Db4oTemplate, probably based on Db4o Native queries (S.O.D.A not doable, unless something is changed on Db4o side)
• Implement the Db4oPlatformTransactionManager and its supporting Db4oUtils classes
• Some day, in the future, provide a Pooled implementation of the Datasource. Inspiration from Commons-DBCP will be necessary :
• A proxy should be created for Db4o ObjectContainer, that would mostly just delegate the processing to a real ObjectContainer, except for the Close(), which would tell the pool that the connection is available

]]> http://www.dalouche.com/wordpress/2006/02/09/springnet-and-db4o-integration/feed/ http://www.dalouche.com/wordpress/2006/02/08/is-architecturing-the-task-of-one-person-not-a-community/ http://www.dalouche.com/wordpress/2006/02/08/is-architecturing-the-task-of-one-person-not-a-community/#comments Wed, 08 Feb 2006 16:33:03 +0000 skoobi Internet http://samokk.is-a-geek.com/wordpress/2006/02/08/is-architecturing-the-task-of-one-person-not-a-community/ This email from Novell is particularly interesting to read.

I believe that they got it right : if you want things to go forward, you sometimes have to create something even though some people won’t like it  sometimes.

It is especially true for Novell, since they are trying to push the .NET framework and as soon as we talk about high level languages, all the C/ASM-lovers stand against it.

]]> http://www.dalouche.com/wordpress/2006/02/08/is-architecturing-the-task-of-one-person-not-a-community/feed/ http://www.dalouche.com/wordpress/2006/02/07/adding-db4o-oo-database-support-for-springnet-transactions/ http://www.dalouche.com/wordpress/2006/02/07/adding-db4o-oo-database-support-for-springnet-transactions/#comments Tue, 07 Feb 2006 23:19:18 +0000 skoobi .NET Tips and Documentation http://samokk.is-a-geek.com/wordpress/2006/02/07/adding-db4o-oo-database-support-for-springnet-transactions/ Compared to its Java peer, Spring.NET’s transaction support is still in its infancy and somewhat undocumented.
According to some posts in the forum, Transaction support should come with version 1.1 (currently in CVS).

In the meantime, those of us who have to deal with transactions still have to find a solution.. The first step is to get a nightly snapshot build of the CVS and copy the Spring.Data classes from the sandbox.

The second step is to understand how Transactions are supported and the last step is to add support for your Data backend if it is not yet supported (only ADO.NET is supported, as far as I know.. Maybe iBatis.Net is too, at least partially).
So, concerning the second step, this thread should help to understand once people give some answers…

This post is to give more details of what I understand in the hope that it will help someone else in the same position :

• First of all, It is necessary to understand the real problem, so here is a scenario :
• A Database maintains all data for a website
• A website has several visitors working concurrently (Several threads will be concurrently accessing the database at the same time, each one serving a visitor)
• It is NOT acceptable (for performance reasons) to open a new connection every time something must be SELECT’ed or UPDATE’d, then closed.
• Database sessions can either be commit’ed (successful registration on the website) or rollback’ed (client gone before the end of the registration).
• Then, it is important to read about Spring (Java) Transaction support, since Spring.NET is highly inspired about its Java counterpart. It’s basically the only documentation we have, so let’s read it, it’s way easier to understand than API documentation
• So, to sum-up Spring Transaction Support: The PlatformTransactionManager (e.g. AdoPlatformTransactionManager for ADO.NET), TransactionSynchronizationManager and Template (AdoTemplate) classes are particularly important.
• All Data access code should be run by PlatformTemplate.Execute (AdoTemplate) that will take care of all the resources initializasation/cleanup, as well as transaction synchronization if necessary (the Template still works if there is no transaction to synchronize to).
• TransactionSynchronizationManager takes care of managing resources and transaction synchronizations per thread. In fact, the problem to solve is about assigning a Transaction and its corresponding connection to every thread that wants to access the database. Depending on the underlying infrastructure and configuration, we may reuse already existing connections -instead of creating and closing systematically - (connection pool such as Commons-DBCP in the Java World) and synchronize them to a transaction. However, this class does not deal with anything else than just keeping the resources of each thread. All the connection/transaction to thread assignment logic is done by the PlatformTransactionManager
• PlatformTransactionManager (AdoPlatformTransactionManager) : this component returns a currently active transaction or creates a new one based on the given parameters (Isolation level, etc).
• TransactionTemplate complements AdoTemplate. While AdoTemplate is used to make sure data access code will be synchronized to a currently used transaction, TransactionTemplate is used to demarcate transactions. In other words, it can be used in non-data access code (higher-level services that use DAOs directly or indirectly), to tell where a transaction begins and where it ends.
• The use of TransactionTemplate is not mandatory, but not using it will imply that calling AdoPlatformTransactionManager methods will be up to the user…
• Declarative TransactionDemarcation can also be used (and is recommended), but for the sake of clarity, we won’t add another layer of complexity here. Spring.NET’s AOP-style declarative transaction demarcation can be seen as the dynamic creation of a proxy around a service class that will just wrap the method calls inside the previously described TransactionTemplate. Then, other beans must use the generated proxy instead of the actual class. But as you can see, the underlying principle concerning Transaction stays the same : we rely on a TransactionTemplate.

So, overall, things do not seem that complex.. Let’s analyze a bit more.

PlatformTransactionManager is the main actor on the scene. Its role is to Create/Reuse transactions, commit and rollback transactions. It conforms to the IPlatformTransactionManager interface that defines the following methods :

• ITransactionStatus GetTransaction( ITransactionDefinition definition );
• void Commit( ITransactionStatus transactionStatus );
• void Rollback( ITransactionStatus transactionStatus );

ITransactionDefinition defines all the gory details of the transaction (Propagation behavior, Isolation Level, Timeout, etc). See Wikipedia for more information about these general Database concepts.

So basically, when we want to perform a transacted set of tasks, the code should look like (taken from Spring Java documentation) :

DefaultTransactionDefinition def = new DefaultTransactionDefinition();
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);

TransactionStatus status = txManager.getTransaction(def);
try {
// execute your business logic here
}
catch (MyException ex) {
txManager.rollback(status);
throw ex;
}

txManager.commit(status);

In other words, this is the manual way of demarcating transactions (e.g. the “wrong” way). But at least, things are pretty clear about what’s done on the system. (txManager is the platform transaction manager, AdoPlatformTransactionManager, for example).

The good news is that it is exactly how TransactionTemplate wraps service code, in the Execute() method :

public object Execute(ITransactionCallback callback)
{
ITransactionStatus status = _platformTransactionManager.GetTransaction( this );
object result = null;
try
{
result = callback.DoInTransaction( status );
}
catch ( Exception ex )
{
rollbackOnException( status, ex );
throw ex;
}
_platformTransactionManager.Commit( status );
return result;
}

As you can see from the code no magic is done here, we purely rely on the PlatformTransactionManager to perform some logic that will make sure the connections and transactions don’t get mixed and matched between threads…

So, let’s see how PlatformTransactionManager works.. Of course, you can already envision that a lot of things are going to be pretty much the same no matter what the concrete platformTransactionmanager is. In fact, no matter whether you use ADO.Net, iBatis.Net, or whatever else, the following workflow handling is hardcoded into AbstractPlatformTransactionSupport, from which all concrete PlatformTransactionsupport should inherit :

• Determines if there is an existing transaction
• Applies the appropriate propagation behavior
• Suspends and resumes transactions if necessary
• Checks the rollback-only flag on commit
• Applies the appropriate modification on rollback (actual rollback or setting rollback-only)
• Triggers registered synchronization callbacks (if transaction synchronization is active)

The basic idea here is that the three methods (GetTransaction(), Commit() and Rollback() are implemented and use the Strategy Design Pattern to delegate actual processing to the concrete subclasses (All the Do*() methods).
So, all the dirty work of complying with the API is already done, and the real work left is about coding the parts that are different with each system, such as beginning a transaction (DoBegin()).

The link with TransactionSynchronizationManager is done, for example in DoBegin by :

TransactionSynchronizationManager.BindResource(DbProvider,
txMgrStateObject.ConnectionHolder);

The ConnectionHolder (which represents the Connection + Transaction) is bound to the thread by the static BindResource which will use a [ThreadStatic] Collection to take care of the Threading stuff. (See more information about the TreadStatic Attribute on MSDN).

However, one thing that I am still unsure about is how connection ressources are disposed. After committing, we do not want to close the session, we just want to tell the PlatformTransactionManager that the resource is now free to reuse for some other thread.

To put it in a nutshell, in order to add support for a new transaction system, here are the required elements :

• a Template class
• A transaction Manager
• Utils class (used by the template and Manager to create/open/close connections)

This should be enough to get a working implementation. I’ll create one for db4o OO database.

]]> http://www.dalouche.com/wordpress/2006/02/07/adding-db4o-oo-database-support-for-springnet-transactions/feed/ http://www.dalouche.com/wordpress/2006/02/07/linux-finally-on-the-desktop-thanks-to-opengl/ http://www.dalouche.com/wordpress/2006/02/07/linux-finally-on-the-desktop-thanks-to-opengl/#comments Tue, 07 Feb 2006 17:23:43 +0000 skoobi Unix / Linux http://samokk.is-a-geek.com/wordpress/2006/02/07/linux-finally-on-the-desktop-thanks-to-opengl/ Thanks to Novell !! See this announcement from Miguel de Icaza or this one from Alexandre Gomes for Xgl and the new compositing manager ..

I am looking forward to having everything working on my Ubuntu box… And having applications (f-spot, etc…) using this technology intensively.

So now, what does the Graphical Layering look like, under Linux ? How is Cairo/Glitz related to Xgl ? As far as I understand :

• Cairo is the equivalent of Apple Quartz: it provides a vector-based graphics library. In other words: an API that allows you to draw lines, rectangles, etc. Cairo then uses one of its backends (such as Glitz) to do the actual rendering
• Glitz is an image compositing library based on OpenGL. It can be used directly, but also integrates with Cairo. An example of OpenGL rendering with Glitz can be found here.
• GTK+ is a widget toolkit that uses Cairo for the drawing of its components. In other words : GTK+ provides windows, buttons, text areas, etc, and Cairo is used to draw the lines to represent these buttons.
• Xgl is the future of X.org Server, layered on top of OpenGL and Glitz.

So, as far as I understand, things would be rendered this way :

• For GTK+ Applications (Inside Application Windows) : GTK -> Cairo -> Glitz -> OpenGL
• For classical X applications using the traditional X API :
• With Xgl : Application -> Xlib -> Glitz -> OpenGL
• With standard X : Application -> Xlib -> Driver-specific acceleration ?

More information about this ?

Other information about the subject :

• NewsForge : X graphics get a boost
• XGL Release
• Xgl unleashed
• Slashdot: Novell makes public Release of Xgl Code
• The official page.
• Novel Linux Desktop Demonstration Videos

]]> http://www.dalouche.com/wordpress/2006/02/07/linux-finally-on-the-desktop-thanks-to-opengl/feed/ http://www.dalouche.com/wordpress/2006/02/07/lightweight-spring-container-vs-ejb/ http://www.dalouche.com/wordpress/2006/02/07/lightweight-spring-container-vs-ejb/#comments Tue, 07 Feb 2006 16:39:27 +0000 skoobi Java http://samokk.is-a-geek.com/wordpress/2006/02/07/lightweight-spring-container-vs-ejb/ This particularly interesting post shows how good Spring is : 70% reduction of code after EJB to Spring migration..

I guess Erik is talking about EJB 2, but it’s still very interesting !

]]> http://www.dalouche.com/wordpress/2006/02/07/lightweight-spring-container-vs-ejb/feed/ http://www.dalouche.com/wordpress/2006/02/07/photography-basics/ http://www.dalouche.com/wordpress/2006/02/07/photography-basics/#comments Tue, 07 Feb 2006 12:54:31 +0000 skoobi Photography http://samokk.is-a-geek.com/wordpress/2006/02/07/photography-basics/ This Topic [Fr] explains photography basics. It is really well done, so it’s worth taking a look at it.

]]> http://www.dalouche.com/wordpress/2006/02/07/photography-basics/feed/ http://www.dalouche.com/wordpress/2006/02/05/dns-registrars-comparison/ http://www.dalouche.com/wordpress/2006/02/05/dns-registrars-comparison/#comments Sun, 05 Feb 2006 11:21:48 +0000 skoobi Internet http://samokk.is-a-geek.com/wordpress/2006/02/05/dns-registrars-comparison/ You can find a nice comparison of DNS Registrars here. All features that matter are compared, thanks to Daniel M. Hendricks !

]]> http://www.dalouche.com/wordpress/2006/02/05/dns-registrars-comparison/feed/ http://www.dalouche.com/wordpress/2006/02/05/digital-cameras-are-getting-better/ http://www.dalouche.com/wordpress/2006/02/05/digital-cameras-are-getting-better/#comments Sun, 05 Feb 2006 09:38:29 +0000 skoobi Photography http://samokk.is-a-geek.com/wordpress/2006/02/05/digital-cameras-are-getting-better/ This CNET article gives the latest trends about digital cameras innovations.

However, what about :

• Better Quality CCD sensors at high ISO settings ?
• A CCD technology that combines the sharpness of Foveon X3 sensors and color reproduction+ISO sensibility of traditional Bayer filters ?

Another thing that I am wondering about is when will Canon release the successor of its EOS 350D digital camera ?

I am planning to buy the EOS 350D, but would prefer to wait until the successor comes out if it is soon going to..

]]> http://www.dalouche.com/wordpress/2006/02/05/digital-cameras-are-getting-better/feed/ http://www.dalouche.com/wordpress/2006/02/04/javaj2eejee-employment-tips-how-to-get-hired/ http://www.dalouche.com/wordpress/2006/02/04/javaj2eejee-employment-tips-how-to-get-hired/#comments Sat, 04 Feb 2006 19:12:29 +0000 skoobi Java http://samokk.is-a-geek.com/wordpress/2006/02/04/javaj2eejee-employment-tips-how-to-get-hired/ Any slightly experienced developer knows that once you have acquired the basic algorithmic, methodologic and design skills, such as the Imperative and Object Oriented paradigms, it is quite easy to learn another language.
If you are quite new to the Java/J2EE world and want to be hired in this area (it looks like most developer jobs resolve around Java/J2EE these days..),  make sure that you first learn, or at least know the basics of all the hype skills in this domain. During any interview, you will get asked, at least, the following set of questions :

• What are Design Patterns ?
• Give a few examples of GoF design patterns and J2EE Design Patterns.
• What is eXtreme Programming ?
• What is Test-Driven Development ?
• What is JUnit ?
• What is a Transaction ?
• What is a distributed transaction ?
• How does the 2-phase commit protocol work ?
• What is Inversion Of Control (IoC) ?
• What are the 3 types of Inversion Of Control ?
• What Inversion Of Control Frameworks are available over there ?
• Give a few examples of J2EE Application Servers
• Give a few examples of Jakarta Projects
• What is Tuxedo ?
• What is Apache Ant ? Apache Maven ? How do they compare ?
• What is Aspect Oriented Programming ?
• What is Object/Relational Mapping ?
• What is Hibernate ? JDO ? SDO ? What do you think about these approaches ?

There are some other recurring questions that I don’t remember, but getting more information on the subjects above will, in any case, help during any interview.

]]> http://www.dalouche.com/wordpress/2006/02/04/javaj2eejee-employment-tips-how-to-get-hired/feed/ http://www.dalouche.com/wordpress/2006/02/04/springframeworknet-still-lacking-db4o-integration/ http://www.dalouche.com/wordpress/2006/02/04/springframeworknet-still-lacking-db4o-integration/#comments Sat, 04 Feb 2006 18:50:09 +0000 skoobi .NET http://samokk.is-a-geek.com/wordpress/2006/02/04/springframeworknet-still-lacking-db4o-integration/ SpringFramework.NET is, to me, one of the best .NET Lightweight Containers available over there. More than just an Inversion Of Control framework, it features an interesting set of features such as AOP (Aspect Oriented Programming).

However, I still haven’t figured out whether Spring.NET has a unified framework for Data Access and Transaction Management as its Java peer. It looks like some of the classes are there, but the reference documentation doesn’t deal with the subject.

Something interesting would be to be able to use declarative AOP-style transaction demarcation  with db4o, the only free OO database available for the .Net platform. Has anyone any idea of how to achieve this ?

]]> http://www.dalouche.com/wordpress/2006/02/04/springframeworknet-still-lacking-db4o-integration/feed/ http://www.dalouche.com/wordpress/2006/02/04/linux-desktop-is-getting-better/ http://www.dalouche.com/wordpress/2006/02/04/linux-desktop-is-getting-better/#comments Sat, 04 Feb 2006 18:24:58 +0000 skoobi Unix / Linux http://samokk.is-a-geek.com/wordpress/2006/02/04/linux-desktop-is-getting-better/ As can be seen from this post (standblog), Novell is preparing some really cool features for Linux’s next-generation Desktop..

Can’t wait to have everything included by default on my Ubuntu box..

A few videos are available.

]]> http://www.dalouche.com/wordpress/2006/02/04/linux-desktop-is-getting-better/feed/ http://www.dalouche.com/wordpress/2006/02/04/keeping-ssh-sessions-alive/ http://www.dalouche.com/wordpress/2006/02/04/keeping-ssh-sessions-alive/#comments Sat, 04 Feb 2006 13:06:21 +0000 skoobi Unix / Linux http://samokk.is-a-geek.com/wordpress/2006/02/04/keeping-ssh-sessions-alive/ This post from Scott Merril explains how to keep SSH sessions alive.

I have experienced the same problem in the past when I was using a kind of cheap router-modem for my Internet Connection..

So, thanks scott, it’s always useful to know why it happened

]]> http://www.dalouche.com/wordpress/2006/02/04/keeping-ssh-sessions-alive/feed/ http://www.dalouche.com/wordpress/2006/01/31/google-creating-its-own-linux-distribution/ http://www.dalouche.com/wordpress/2006/01/31/google-creating-its-own-linux-distribution/#comments Wed, 01 Feb 2006 07:21:03 +0000 skoobi Unix / Linux Rumors http://samokk.is-a-geek.com/wordpress/2006/01/31/google-creating-its-own-linux-distribution/ Apparently, quite a lot of blogs ( BlogORabais , Je Hais le Printemps) and news sites (Slashdot, The Register) are relaying the information…

So, what is Google currently preparing ? Is this information a whole FUD started by Google , just to make this company even more popular ?

In any case, this can only benefit the Ubuntu, Debian  and more generally, the Linux communities. So, Long life Google….

]]> http://www.dalouche.com/wordpress/2006/01/31/google-creating-its-own-linux-distribution/feed/ http://www.dalouche.com/wordpress/2006/01/26/servicemix-jbi-container-and-pxe-bpel-theory-and-practice/ http://www.dalouche.com/wordpress/2006/01/26/servicemix-jbi-container-and-pxe-bpel-theory-and-practice/#comments Thu, 26 Jan 2006 20:18:22 +0000 skoobi Java Tips and Documentation http://samokk.is-a-geek.com/wordpress/2006/01/26/servicemix-jbi-container-and-pxe-bpel-theory-and-practice/ While speaking about a work I achieved last summer, related to ServiceMix (a JBI container) and PXE ( a BPEL engine that can be embedded inside ServiceMix), a friend of mine came up to the following conclusion :

In theory, theory and practice are the same whereas in practice, they are not.

I love that sentence

So, here is a small HOWTO, taken from the email I sent to ServiceMix mailing list :

How to get a BPEL process running with ServiceMix JBI Container and Fivesight's
PXE :
===

1) The first step is to create a BPEL process with the corresponding WSDL files.
Examples bundled with PXE can serve as a quickstart.

2) Remove any concrete bindings in the WSDL Files (
binding and service XML tags). Indeed, the endpoints are JBI proxies, so the
SOAP over HTTP bindings are useless here. PXE and ServiceMix will take care of
registering ports as JBI Service endopints.

3) Compile your BPEL process and WSDL files
let's say the main WSDL file describing the process is in the
MissionPlanningProcess.wsdl (this file must import the other WSDL files that
are
used :

REM add the resources to PXE's Resources Repository MissionPlanning.rr
rradd -wsdl file:MissionPlanningProcess.wsdl MissionPlanning.rr

REM compile the BPEL
bpelc -rr MissionPlanning.rr -wsdl file:MissionPlanningProcess.wsdl
file:MissionPlanning.bpel

4) Create a pxe-system.xml file that describes how to bind the BPEL process to
actual JBI endpoints. (PXE's deployment descriptor)

Let's say that the MissionPlanning process provides 3 portTypes :
proc:ProcessPT, proc:CallbackPT, resp:ResponderPT.

We want to expose 2 services :
ProcessSVC that exposes the proc:processPT and proc:CallbackPT porttypes
and
ResponderSVC that exposes the resp:ResponderPT portType.

(same names as the Async example bundled with PXE)

the corresponding pxe-system.xml file would be :

http://www.w3.org/2001/XMLSchema-instance";
xsi:schemaLocation="http://www.fivesight.com/pxe/system-descriptor/
http://www.fivesight.com/pxe/system-descriptor/”;
wsdlUri=”file:MissionPlanningProcess.wsdl”
xmlns=”http://www.fivesight.com/pxe/system-descriptor/”;
xmlns:proc=”uri:concordia.ciise.weather.process”
xmlns:resp=”uri:concordia.ciise.weather.responder”>







Pay attention to use the same value for the “name” attribute in the
system-descriptor tag, as the name of the BPEL process. (current limitations
with PXE, should be fixed in the future)

5) We now have all the necessary artifacts to create a SAR (System Archive) file
that is just a container for all these files :

sarcreate -common MissionPlanning.rr -sysd pxe-system.xml MissionPlanning.cbp
pxe.sar

6) JBI needs deployable components (the SAR in this case) to be contained in a
zip file. The zip file is referred later as a Service Unit. (hence the -su)

=> create the output directory
=> jar cf outputMissionPlanning-su.zip pxe.sar
(or use any tool that can create a .zip)

7) Package this service unit inside a so-called Service Assembly (SA), which is
just a set of service units with a jbi.xml
For example, create the following outputMETA-INFjbi.xml file :

http://java.sun.com/xml/ns/jbi  ./jbi.xsd”
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”;
xmlns=”http://java.sun.com/xml/ns/jbi”;>

MissionPlanningSA
Service Assembly containing just the BPEL
deployment.

MissionPlanning
BPEL Service Unit

MissionPlanning-su.zip
PxeBpelEngine

and create the jar :
cd output
echo creating Service Assembly
jar cf ..MissionPlanning-sa.jar *
cd ..

component-name refers to the name of the BPEL engine deployed in the JBI
container.

8) Create a servicemix.xml file that launches a JBI container.
An example is bundled with ServiceMix’s AsyncDemo example :
Pay attention to :

and

in the installationDirPath, you will have to drop the PXE’s JBI component.
(bundled with ServiceMix). If ServiceMix doesn’t detect PXE nor install it, then
it means there is a problem in your installationDirPath. (For example, if
ServiceMix is integrated inside Geronimo, the “.” directory refers to
GERONIMO_HOME

the deploy directory is where you will drop the Service Assembly

9) launch service mix (either standalone, or by sourcing the spring file.
If you source the spring file, make sure you use ServiceMix’s Spring version.
The XML extension mechanism is not yet available from upstream Spring, so
Spring won’t recognize servicemix’s specific spring syntax.

10) Here you go, you can then talk to your BPEL process from other JBI
components (more information in another HOWTO)

I hope that this HOWTO will help someone some day...

]]> http://www.dalouche.com/wordpress/2006/01/26/servicemix-jbi-container-and-pxe-bpel-theory-and-practice/feed/