I can’t remember the first code challenge I got in my interviews, but there’s one think I’m completely sure … I HATE THEM.

Don’t misunderstand me, I’m just bad at generating an algorithm in the middle of an interview with 30-40 minutes to examine, analyze, create and code a solution. I like to solve problems trough a code challenge, but for me it takes time.

BTE , I’d like to have a history of what kind of code challenges I got I’m gonna post the challenge and as soon I have a solution I will post it.

The challenge..

This challenge was for a Python position, basically says :

Challenge:

“Sort the next list in a natural order”
List:
filenames = [‘bs1-2.png’, ‘bs1-10.png’, ‘cs1-1.png’, ‘bs1-1.png’, ‘cs1-2.png’, ‘cs1-10.png’]

Natural order means we are expecting to be sorted like this:

['bs1-1.png', 'bs1-2.png', 'bs1-10.png', 'cs1-1.png', 'cs1-2.png', 'cs1-10.png']

So, according to this using list.sort() will not give us the expected result.

And many people will say this is an actual easy challenge, well, not for me because I’ve never done this without using a compareTo like method.

My approach

Now, since python sort function has a key parameter that acts like the Java compareTo method the documentation is not very clear about what actually the method will receive, and again 20-30 minutes to analyze the problem.

My first approach was to compare every character from every pair of words in a bubble sort -like algorithm, but then this was not viable because you must be sure both words contains the same amount of characters.

Next approach : Ok, so, let’s assume the ascii table assigns a numeric value for every char, what about getting every numeric value from every character in the word, sum everything and compare with the next word value and sort based on this value. But I was not pretty sure if this was viable.

The result..

I didn’t get the position of course, but hey, I really did my best trying to find a solution. Then I googled and found I was not too far from the right answer:

• Yes, the key parameter was part of the solution

• Getting the numeric value of the word was actually… part of the solution :

filenames = ['bs1-2.png', 'bs1-10.png', 'cs1-1.png', 'bs1-1.png', 'cs1-2.png', 'cs1-10.png']

def natural_key(string_):
    return [int(s) if s.isdigit() else s for s in re.split(r'(\d+)', string_)]

filenames.sort(key=natural_key)

print(filenames)

Update: What’s going here?

• The key function will divide every string using a regex and put into a list every string fragment, and numbers, and then return the list in order to be compared with another element in the string list.

So well, I will assume I have a lot of work solving challenges, but actually I did better than expected .

I really wanted to move because I found I was doing the same over and over and my schedule was so tough for develop more skills (an 11 hours workday), so when this offer popped up I said “this is my chance”.

And well, as soon I started to get interviewed for getting a project I realized how bad my skills were, I lacked a lot of english communication, I mean, the english was there, just I was not too comfident, fortunely a good friend helped me to sort this problem.

Next, and a reason why sometimes I feel some depresed is the tech skills.

I really love to develop software, from mobile apps, doing tests with API’s and creating new API’s to being part of a huge project like in my past job, and I really thought I was really good with Java.

But after my first interview was like a cold water bucket in my head, I really needed a lot of training with new technologies, algorithms, problem solving. This gave me the enough ingredients to have what it’s known as “impostor syndrome”, sometimes I think I’m not just good as I tought.

On the positive side, I have learned a lot during this 4 months, new frameworks, a lot from the JDK core, how is built from inside, serverless architecture, and a lot.. I mean A LOT of softskills.

I feel like 3 years ago when I was unemployeed, I remember to said “I JUST NEED A CHANCE TO SHOW WHAT CAN I DO!!” , so I’m still looking for a chance (I just hope I don’t get fired before the chance comes up) .

Las pocas personas que aun quedan suscritas via feedburner probablemente notaran que a su correo han vuelto a llegar notificaciones de éste sitio. 

Este blog nació como una “libreta de notas” por ahí del 2012 aproximadamente mientras estaba a la mitad de mis estudios de preparatoria. 

Necesitaba un lugar donde plasmar lo que iba entendiendo, de esta forma puedo generar una relación mas fuerte del nuevo conocimiento adquirido e incluso formular ejemplos para complementar el post.

Desgraciadamente al entrar a la universidad y entrar a trabajo de medio tiempo (y en adelante) no me dio tiempo de continuar con el blog .

Actualmente he retomado el blog y le di un pequeño ajuste, limpie (literalmente) todo lo anterior pues la mayoría eran conceptos que ya no son muy validos actualmente o están desactualizados y he empezado a plasmar algunas cosas que he aprendido recientemente.

Adicionalmente, el sitio lo estoy escribiendo en ingles a fin de familiarizarme totalmente con términos técnicos en ingles para que me sea mas fácil contestar alguna pregunta o dar una platica en éste idioma, esto sigue a una necesidad de hacerme mucho mas fluido al expresarme y comunicarme en inglés  puesto que quiero romper el “si se, pero me falta”. 

Eventualmente agregare posts como este en español, bajo la categoría spanish, y con el prefijo [ES]. 

As part of my intensive Java training I got asked to review the source code of the common collections in the JDK. 

I started by cloning the JDK Mercurial repository and checking the ArrayList implementation, and it’s a surprise to see there is not black magic in the code, is the same code that you or me may create for solving the same problem: create a resizable array with common operations. 

The arraylist has internally an Object array that stores every object added through the constructor or the add, addAll operations. The “black magic” comes when you find the arrays can’t be resized, so how the ArrayLists manages to do this. 

Well, when you call the constructor without a collection to add (the empty constructor) the array is initialized empty. When you use the constructor with a collection will use the Arrays.toArray method to store your collection.

Any time you call the add() method java ensures there is enough space , and grows the array +1 by making a new one, copying the elements of the previous array and adding the new one on the new space (see the code below).

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

The maximum length of the ArrayList is the Integer.MAX_VALUE or 2,147,483,647 elements since the list relies on a standard array.  After reaching this size any subsequent try to add elements will result on an out of memory exception.

I will write about the delete, addAll and the basic methods specified on the List interface and how ArrayLists implements them in the next posts. 

TL;DR

When we pass an object (or an object “reference”) to a method we are actually passing a copy of the bits in the reference, so is passed by value

This is a really really tricky question, since many people thinks that you are actually passing a reference to a method (an object reference of course) and not the object itself.

And this is half true

We need to define what actually which information holds the object reference, in this case a variable holds the exact bits that tell the JVM how to get the referenced object in the Heap (the java space in memory) .

So when we pass an object (or an object “reference”) to a method we are actually passing a copy of the bits in the reference, this may look like 3bad086a, and not the reference itself neither the object. 

So, the next time someone asks you if Java is “passed by value” or “passed by reference” you know the answer and why is actually passed by value.

A String in Java, in short words, is an object that stores a sequence of characters, think on a “char array”. But doesn’t have a char array internally.

Also in Java, Strings has some interesting qualities:

• Strings are immutable objects, this means once is created can’t be modified.
• Like any other class in java, extends from the Object class, so Strings contains its numeric representation trough the hashCode() method.
• Strings can be directly instanced with quotes (“”) and using the “new” key word for the constructor.
• The main difference between using quotes and the constructor is the String Pool.
• The String pool is a reserved area in the JVM heap, which will store Strings for a future recycling, this means, if you declare a string like String a = “cat”, and then , String b = “cat” . Instead of creating a new String object, Java will check if the string already exists in the pool then will return a reference to the same memory location. But if doesn’t exists it will create a new string in the pool and return the reference instead.
• On the other hand, when you use the new (constructor) for instantiating a String, Java forces the creation of a new String object directly on the heap space.

I just learned there are some (not very known) modifiers in the Java language, one in particular is called strictfp.

Natively, java uses the IEE754 for the float and double values , but it can extend the the exponent range where available resulting in more precise results.

But, when we use the keyword strictfp in a class or a method, we are forcing the results of floating-point calculations to be IEEE754, ensuring an identical result on every platform.

This keyword can be used on classes or methods just like the next code shows:

public strictfp class SomeClass {

    ... 
}

public  class SomeClass {

    public strictfp Double someMethod(){
      ...  
    }
}

Depending where is used it will be the scope of the IEEE754 FP calculations and using the strictfp you may not be able to use some JAVA capabilities for floating point.

One of the most important concepts that I was asked for in my last job interview was “what is SOLID?, are you familiar with the SOLID principles?”  .

And this is important because SOLID stands for five principles for object designing, you known, before start coding you should design your solution.. right? ….. right? ok.

So what SOLID stands for?

S : Single responsibility – Your class must have one single responsibility, if you are creating a class for “sending a mail” that is the only task that should do, not validating, not connecting, not applying a template, only to send the mail, the other tasks should be done by other classes.

O : Open/Close – When you are designing an application that probably will be need extended in the future, you should be sure that your design is open to extend the functionality but closed to modify it. If you need to modify a core functionality in order to update your application then your design is probably incorrect.

L : Liskov Substitution – After te “O” principle is when SOLID starts to be interesting. Liskov Substitution states that  subclasses  must be suitable for the parent classes,  in other words, if you are inheriting a parent class and you HAVE to override a method with a “return null” or throwing a “NotImplementedException”or you completely changed the functionality of the parent method then you are violating the Substitution Liskov .

I : Interface segregation- This is very similar to Single responsibility but applied to interfaces, interfaces are for the clients not for the application. So you want to segregate your interfaces in particular tasks rather than create a giant interface that makes everything and your client has to create dummy implementations.

D: Dependency Injection – This principle is the most important, DI allows to build loose coupled code, because other class doesn’t know the details of how create an instance another method to start working with it. Instead calling a constructor  a DI manager will inject the instance to the class through the constructor or a setter method.

When you look for a MVC framework you will find there is two main candidates: Struts 2 and Spring Framework.

I will not argue which is better, because both are a fit for different situations , not only technical situations.

TL;DR , the main difference between Spring MVC and Struts 2 is the way they handle the requests, Spring MVC IS a servlet while struts 2 uses a filter to execute the action, BUT the learning curve of Spring 2 is way shorter than Spring MVC, if you have a very very complex requirement for a short time you can build an elegant and robust solution with Struts 2, if you have experience with spring and your backend already uses spring framework your best choice is Spring MVC.

Spring MVC

Spring MVC is part of one of the biggest frameworks available for Java :Spring Framework, relies on IoC (Inversion of Control) and complements the OOP with Aspect Oriented Programming by using the dependency injection.

So this means, when you are using Spring MVC you probably have a backend made with Spring so you can access to the application context and work with the beans that are loaded by injecting them to your MVC Controller.

Finally, Spring MVC is designed around a dispatcher servlet that catch all the incoming requests and dispatches to the handlers, so it’s a servlet.

Struts 2

Struts 2 is a stand alone MVC framework which means  you are not tied to a technology in particular, you can integrate it easily with Hibernate, JSP, Spring, etc. In the “old days” you were tied to JSP for the view layer, but now thanks to the plugins you can create a modern singlepage site in integrate it with Struts 2.

Struts 2 uses the Filter from javax to intercept the requests and choose the action required to process it.

The filter (since struts 2.3) is the PrepareAndExecuteFilter that handles the incoming request, for its preparation and execution. So when a new requests is passed by the filter it will search for the required action, then the request is passed to interceptors that will execute tasks like validations, then is passed to the action class to process and generate a result.

The result is passed back by interceptors too and finally the PrepareAndExecuteFilter will deliver the result to the client.