Uno scrittoio digitale …

24 maggio 2016

msgpack

Archiviato in: code — Tag:, , , , — admin @ 09:18

It’s like JSON. but fast and small.

13 aprile 2015

Run your code online

Archiviato in: code — Tag: — admin @ 10:14

http://runnable.com/

Fatto veramente bene e molto semplice da usare.

10 ottobre 2014

Jcabi

Archiviato in: code, java — Tag:, , — admin @ 17:42

hanno sviluppato un casino di progetti … come si può vedere qua

26 luglio 2014

Ruby and Rails

Archiviato in: Senza categoria — Tag:, — admin @ 08:15

Inizio a capirci qualcosa ed ho deciso di annotare qualche link veramente importante:

readruby.io
guides.rubyonrails.org
rspec.info
pryrepl.org

23 gennaio 2012

AspectJ

Archiviato in: java — Tag:, , — admin @ 22:44

Constructors are tricky in Java, and that’s exposed in AspectJ. Here are some rules of thumb I use:

* If you want the join point on the “outside” of object creation, use:

after() returning (Foo f): call(Foo.new(..)) { … }

you might be tempted to use “this” or “target” to expose the new object, but remember
that if you’re on the “outside” of object creation, the object itself might not be
created yet… it only exists “on the way out”, when you return the object.

* If you want the join point inside a particular constructor, use:

after(Foo f) returning: this(f) && execution(Foo.new(..)) { … }

remember, though, that if you use “before” advice here, the body of the constructor
will not have run, and so the object may be somewhat uninitialized.

* In the rare case that there are all sorts of constructors for the object
that call each other with this(…) and you want exactly one join point
for each initialization of Foo, regardless of the path of constructors it takes,
then use:

after(Foo f) returning: this(f) && initialization(Foo.new(..)) { … }

Enjoy,

4 dicembre 2011

Java Custom ClassLoader

Archiviato in: code, java — Tag:, — admin @ 15:43

Due istanze della stessa classe, hanno realmente la stessa classe solo quando queste due sono create con lo stesso class loader …
dimostrazione:

final Class loadClass = new MyClassLoader().loadClass(SimplePojo.class.getName());		

Object newInstance = loadClass.newInstance();
printInformation(newInstance);

final SimplePojo simple = new SimplePojo();
printInformation(simple);			

System.out.println(
	"check: " + simple.getClass().equals(newInstance.getClass())
);			

final SimplePojo simple2 = new SimplePojo();
printInformation(simple2);	

System.out.println(
	"check: " + simple.getClass().equals(simple2.getClass())
);

L’output è:

name of class: it.skb.at.reflection.SimplePojo
name of class loader: it.skb.at.reflection.MyClassLoader

name of class: it.skb.at.reflection.SimplePojo
name of class loader: sun.misc.Launcher$AppClassLoader

check: false

name of class: it.skb.at.reflection.SimplePojo
name of class loader: sun.misc.Launcher$AppClassLoader

check: true

Che ficoooo :D

9 ottobre 2011

Python Libs

Archiviato in: code, python — Tag:, , — admin @ 12:54

Due progetto da tenere sott’occhio:

you-tube
networkx

8 ottobre 2011

execute code online

Archiviato in: code — Tag: — admin @ 14:20

ideone

13 marzo 2011

Domanda frequente

Archiviato in: java — Tag:, — admin @ 12:44

Vi è mai capitato di usare una classe di un package non scritto da voi … magari senza documentazione o test ?
Bene, invece di usare l’approccio WTF … esiste un mitico sito che ci aiuta a capire come si usa un’API
http://www.javadocexamples.com/

29 gennaio 2011

Another Java Proxy

Archiviato in: java — Tag:, , , , — admin @ 14:39
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class TraceProxy implements java.lang.reflect.InvocationHandler {

	private Object object;

	public static Object createProxyFor(Object object) {
		final TraceProxy traceProxy = new TraceProxy(object);
		System.out.println("\ntraceProxy = " + traceProxy);

		return Proxy.newProxyInstance(
			object.getClass().getClassLoader(),
			object.getClass().getInterfaces(),
			traceProxy
		);
	}

	private TraceProxy(Object object) {
		this.object = object;
	}

	@Override
	public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
		System.err.println("traceProxy = " + this);
		System.err.println("m = " + m);
		System.err.println("args = " + args);

		if (args != null) {
			for (Object object : args) {
				System.err.println(object);
			}
		}

		return m.invoke(object, args);
	}

	public static void main(String[] args) {
		CharSequence cs = (CharSequence) TraceProxy.createProxyFor("abcdefghilmnopqrstuvz");

		System.out.println("\ncall charAt");
		System.out.println("charAt result is '" + cs.charAt(2) + "'\n");

		//sleep ... altrimenti l'output non è chiaro
		try { Thread.sleep(10); } catch (InterruptedException e) { }

		System.out.println("call length");
		System.out.println("length result is '" + cs.length() + "'");
	}
}

8 gennaio 2011

Paura della UI ?

Archiviato in: java, linux, python, sapere è potere — Tag:, , — admin @ 21:57

Ecco un mitico software che aiuta in fase di creazione del nostro applicativo … Glade

28 luglio 2010

base Refactoring

Archiviato in: code — Tag:, , — admin @ 21:18

Applica costantemente i seguenti concetti per mantenere il codice pulito …

  • metodi di piccole dimensioni
  • nomi significativi a classi, metodi e variabili
  • ogni metodo deve fare una singola operazione
  • creare sottoclassi per aggiungere funzionalità invece di aggiungere metodi alla stessa
  • estrarre classi prima di ottenere un casino di codice
  • mantenere l’astrazione nelle classi
  • ogni classe dovrebbe eseguire una singola responsabilità

sicuramente può essere rifinita ed aggiornata … ma questa breve lista dovrebbe essere un buon punto di partenza.

21 giugno 2010

Piccolo teorema di Fermat

Archiviato in: code, sapere è potere — Tag:, , — admin @ 20:18

Come ho fatto a vivere senza questa informazione ? facile … basta non pensarci :D
Piccolo_teorema_di_Fermat

Una mia ( e rozza ) implementazione in Python … ATTENZIONE ALL’INDENTAZIONE !!?

"""
Simple implementation of Fermat's little theorem
"""

import sys

def main():
	args = sys.argv[1:]
	if (len(args) != 1):
		print "Give me only one number ..."
	else:
		cn = int(args[0])
		interval = range(cn)[1:]

		p = cn	#otherwise fail with parameters '1'
		for p in interval:
			r = ((p ** cn) - p) % cn
			if (r != 0):
				print cn, "/", p, "=", r
				print cn ,"is not PRIME"
				p = -1
				break

		if (p != -1):
			print cn ,"is PRIME"

if __name__ == "__main__":
	main()

Vorrei migliorarlo … basta vedere che per sapere se 10169 è primo o no … sul mio pc sono richiesti quasi 2 min.
Chi mi aiuta ?

12 agosto 2009

Java EnumMap

Archiviato in: code, java — Tag:, , — admin @ 18:00

In un paio di contesti ho dovuto usare una strategia non proprio bella … xò molto efficace per costruire un nuovo oggetto a partire da alcune proprietà passate. Per non riempire il codice di un numero abbastanza considerevolte di setter e/o di costruttori ( con tutte le combinazioni possibili di proprietà ) … ho usato una mappa come DTO e tramite un builder costruivo il nuovo oggetto. Giustamente per dover dare un feedback al client che usa il mio builder … prima di costruire il nuovo oggetto controllavo che nella mappa passata ci siano tutte e sole le proprietà richieste. Oggi ho scoperto un modo abbastanza più elegante e sicuramente molto meno incasinato per fare lo stesso lavoro: EnumMap .

Funziona con WordPress