Sunday, November 18, 2012

Fancy a cup of tea?

In most parts of Eastern Europe, they often drink it with lemon and honey,
in India with milk and cardamom,
in Spain they drink it just with sugar,
in Ireland they drink it with milk and some people with a fascinating new taste called brown sauce (If you dont belive me see this movie: Intermission).

But in all cases the recipe has 2 mandatory components:
  1. Boiling water
  2. Tea

In this video I am going to talk about a new design pattern that was created by Marco Castigliego, called
"The Step Builder".

"The Step Builder" is a variant of the creational pattern "Builder".
The advantages of using Castigliego's pattern are:

  • The user will see only one or few selected methods per time during the Object creation.
  • Based on the user choice different paths can be taken during the Object creation.
  • The final build step will be available only at the end, after all mandatory steps are completed returning an Object in a consistent state.
  • The user experience will be greatly improved by the fact that he will only see the next step

 methods available.

More information about this pattern and also a wiki definition of it can be found at Marco Castigliego's blog: Remove duplications and fix bad names

 Note: Don't forget to select the maximum quality in the video player

Monday, November 12, 2012

The all mighty regex

We often use regular expressions when programming.
In many occasions they make our live easier and help us avoiding lots of lines of code. I was just navigating around, and by a chance I found a blog that shows probably the one of coolest regex.
Have a look at this regular expression:

Personally I never used this one before. The thing that I find cool about it is, its simplicity.
For those who are not familiar with regex terminology, this one matches a character that is within(inclusive )the characters SPACE and tilde in the ASCII table.

Hehe.. cool, isn't it? I am looking forward to use it somewhere.

I can't resist, let's just give it a quick try :)

1:  import java.util.regex.Matcher;  
2:  import java.util.regex.Pattern;  
3:  public class AllMightyRegex {  
4:       public static void main(String[] args) {  
5:            String someASCIICharacters = "!#$%&\'()*+,-.0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";  
6:            Pattern pattern = Pattern.compile("[ -~]");  
7:            Matcher matcher;   
8:            for (int variableIndex = 0; variableIndex < someASCIICharacters.length(); variableIndex++) {  
9:                 matcher = pattern.matcher(getCharAt(someASCIICharacters, variableIndex));  
10:                 if(matcher.matches()) {  
11:                      System.out.println("The character: " + getCharAt(someASCIICharacters, variableIndex) + " matches the pattern");  
12:                 }  
13:            }  
14:       }  
15:       private static String getCharAt(String someASCIICharacters,  
16:                 int variableIndex) {  
17:            return someASCIICharacters.charAt(variableIndex) + "";  
18:       }  
19:  }  

Tuesday, November 6, 2012

How to print into a remote application server log with eclipse.

  1. From the debug perspective access the debug configurations
  2. Use the Remote Java Application option in the debug menu to create a new debug configuration.
  3. Enter the ip of the remote host and the debug port.
  4. Click on Debug
  5. Once the debugger is hooked, open the display view
  6. Type the command you want to execute and execute it.
  7. tail -f of vi into server.log file to see the results

Thursday, November 1, 2012

How to conquer the world? Well... you need a strategy

This weekend i went through old notes i had on  my hard disk, I wanted to refresh my mind about some design patterns.
Patterns is a topic I like very much and from my point of view they represent some foundation which is mandatory to understand if we want to have better understanding of software architectures.
The most popular authors that wrote about design patterns are known as GoF (Gang of Four), we could say that they are the icon every developer looks at when talking about design patterns. Their writings are present in almost every university and in many occasions are even a mandatory subject(Well.. at least it was in mine :) ).

I think the "Strategy" pattern was the first, or at least one of the first patterns i studied when I started with java. Also i noticed the large amount on articles on the web about this pattern.
Here a really good one you can read latter (But for now, focus on my one ;) ).

So since this pattern is so popular, and interesting, maybe it deserves a post.
Also since there are many articles on this topic already on the internet and all of them are very similar, I thought about making a little surprise at the end of my  presentation, to make it more fun and beautiful.
I hope you like it.

Note: Don't forget to set the quality to HD in the video player

Share with your friends