Hoy me levanté y no tenía servicio en mi teléfono, tenía entendido que antes debía llegar un SMS que avisara el día exacto en el que se produciría el cambio, pero nunca llegó. No se si la responsabilidad de dicho SMS es de la empresa que dejas (en mi caso Personal) o de la entidad intermedia que se encarga del cambio, tal vez lo averigüe luego para saber a quien culpar.

Como me queda de camino al trabajo, pasé por las oficinas de Claro para que se fijen si el trámite estaba terminado (y para cambiar mi SIM por un micro SIM, ya que no te lo dan directamente cuando inicias el trámite) y me puse contento de ver que ya estaba la línea Claro activa.

Simplemente cambié el chip, y voilà! Super velocidades de datos, justo lo que el médico me recetó!

Espero que sea el inicio de una larga relación de intercambio de dinero por felicidad en forma de transmisión de datos.

- “Pero, seguro es una sensación tuya!”

Eso sospeché, pero por suerte tengo amigos que tienen Claro que me pudieron prestar su SIM para usar en mi teléfono.

El resultado? Una imagen dice mucho

- “Pero, cuanto te daba con Personal?”

No salió de ahí.

En fin, terminé el trámite el viernes (que fue muy sencillo, se hace directamente en la compañía destino, con el DNI, la última factura de la compañía anterior, y el comprobante de pago de dicha factura — del resto se encargan ellos) y hoy (lunes) recibí el adiós de personal

Personal te agradece haber sido parte de esta experiencia. Podes regresar en 60 días. Seras Bienvenido.

No creo que lo haga, pero gracias!

Bah… si Claro se convierte en la mala, y Personal mejora, tal vez lo haga… es la gracia de esta ley.

I experimented with a lot of ways to package it and make it self-contained, like the Maven Assembly Plugin, but it behaved weirdly… I wasn’t even able to track exactly what it did.

I eventually settled with creating a package file that contains the main application jar file, and all its dependencies in a /lib directory with the Maven Dependency Plugin – simple and awesome.

All you need to do is add the following configuration to your pom.xml file:

<build>
	<plugins>
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-dependency-plugin</artifactId>
			<version>2.4</version>
			<executions>
				<execution>
					<id>copy-dependencies</id>
					<phase>package</phase>
					<goals>
						<goal>copy-dependencies</goal>
					</goals>
					<configuration>
						<outputDirectory>${project.build.directory}/lib</outputDirectory>
					</configuration>
				</execution>
			</executions>
		</plugin>
	</plugins>
</build>

And run mvn package. This will generate the files in your /target directory

Running that application, is easy using the ProcessBuilder class and a little script to build the command line… command.

I created two sample projects that you can download from GitHub to see this working, but the gist of it is this (this is the run.sh file you can find in the samples):

cd $1
jars=""
for i in *.jar lib/*.jar;
do
    jars=$jars$i":";
done
java -Dfile.encoding=UTF-8 -cp $jars. com.seniorgeek.samples.scfj.program.App

To see it working you need to:

1. Download the samples
2. Run mvn package on Program
3. Copy the main jar and the /lib directory in /target to /workspace/test1 in Executor
4. Run Executor

That’s it, if everything works, you can see in your console a greeting to the universe (greeting just the world is getting old).

Program has some dummy dependencies in its pom file just to illustrate the example, you can ignore them.

Let me know if you have any problems or questions.

I heard a few coworkers talking about jetty, and I decided I wanted to try it in a project I’m working on.

Jetty provides an HTTP server, just like Tomcat, but you can create it from within your application, instead of having your application run “inside it”. This allows you to run your application as a Java app and provide an HTTP endpoint, without any need to administer something external to it like a Tomcat.

I created a sample application that uses Jetty with Spring MVC (with a custom view resolver that transforms any object returned to json). You can download it from github.

As you will see in the sample, it couldn’t be easier to use, the most relevant part is when you create the jetty server:

Server server = new Server(8082);
Context root = new Context(server, "/", Context.SESSIONS);
DispatcherServlet dispatcherServlet = new DispatcherServlet();
dispatcherServlet.setContextConfigLocation("classpath:application-context.xml");
root.addServlet(new ServletHolder(dispatcherServlet), "/*");
server.start();

That will create an HTTP server on port 8082 and initialize Spring MVC (be sure to have all dependencies in your pom.xml file, see the sample).

The next thing I wanted was to have any object returned transformed into json. For that, I created a custom view resolver that just gets the view and adds the object to it, like so:

public class SampleModelAndViewResolver implements ModelAndViewResolver {
    public ModelAndView resolveModelAndView(Method handlerMethod,
        Class handlerType, Object returnValue,
        ExtendedModelMap implicitModel, NativeWebRequest webRequest) {

        ModelAndView v = new ModelAndView("jsonView");
        v.addObject("data", returnValue);
        return v;
    }
}

If you download the sample and run it with eclipse (as a Java app), you will see than in less than 2 seconds you can navigate to http://localhost:8082/data and get an object formatted as json

I hope this helps anyone that wants to try this stuff, let me know in the comments if you have any problems with it!

That baby was awesome to quickly take a screenshots and paste them in gmail, or whatever tool you needed.

When I was in Linux, I found shutter but, as everything in Linux, it was not pretty and not so easy to use.

After I arrived in MacOS, that is the first thing I looked for and, luckily, it was integrated into the operating system.

These is how you do it:

• Save screenshot of entire screen as file in the desktop: Shift + Cmd + 3
• Copy screenshot of entire screen to clipboard: Shift + Cmd + 3 + Ctrl
• Save screenshot of window as file in the desktop: Shift + Cmd + 4 and then Space
• Copy screenshot of window to clipboard: Shift + Cmd + 4 + Ctrl and then Space
• Save screenshot of arbitrary area as file in the desktop*: Shift + Cmd + 4
• Copy screenshot of arbitrary area to clipboard*: Shift + Cmd + 4 + Ctrl

*: This is the snipping tool behavior that is not present in Linux

As you probably also noted, the difference between saving as a file and copying to the clipboard in each case, is Ctrl

My first (real) computer came with Windows 95 (That’s not counting my commodore 128… although I should, because that’s what started my love for technology when I was just a little boy).
Right about that time, I started using them in high school and they all came with windows (3.1 some of them), and I had no idea there was something else — computers were not that cheap in those times, and not everyone had access to them here, so there wasn’t much variety out there, and no internet yet.

After I graduated high school, I got my first job as a programmer — VB6 and ASP classic were the first things that earned me my first bucks.

My professional career then led me to learn .NET, and that’s what I’ve been programming ever since — from the early betas to 4.0.

That was my focus until my current job, where they decided to replace all Microsoft technologies for alternatives, and all programming shifted to Java.

I seized the opportunity to learn new stuff and joined the Research & Development team, where the job description was exactly that: Research new stuff, try it, see what works, be creative.

The most awesome thing that came out of it, was migrating from SVN to GIT.
That, again, forced my hand. GIT support for Windows is not… good. Sure, you have a few tools, like Tortoise Git and msysgit – which are good, but not that good.

It was time to take another step and try Linux. I installed Ubuntu with dual boot (just in case I needed my Windows for something), eclipse, and Git. After a few (a lot) of headaches, I got everything working, and it was awesome. I discovered the power of the command line!

Nothing beats using Git from a console.

But I wasn’t that comfortable really. Eclipse looked awful, making it look good was difficult and I wasn’t even able to make Steam work (no support, and WINE is just not prepared for it).

I felt like Windows was in one end: user friendly, easy, and pretty, but when you want to do more, you hit walls. Linux was on the other end, you can do a lot of stuff, but everything is very manual (granted, there is A LOT of support, and everything was done by someone else in the past but hey, it’s work too) and complicated, from installing a printer to connecting to a VPN, a lot of stuff to be done.

And so I found myself wishing there was something in between. Something pretty like Windows and powerful like Linux.

“There is something I’m yet to try” I thought to myself. And that thing was MacOS. So I went out and bought myself a MacBook Air.

Oh boy… it’s awesome. Everything I need to work, just works, and all I need to do, I can do.

Sure, they are expensive, but so worth it. I would highly recommend getting one if you can.
I instantly loved it and, after one day, I had everything working as I wanted it, and once I learned the hotkeys and to use its awesome trackpad, my productivity increased a lot.

If only there was a Windows Live Writer alternative for MacOS, I’d be a really happy guy.

Well, that’s the present. We’ll see what’s in store for me in the future… all I hope for is that it’s awesome.