Banshee's stuff

An aleph-zero potpourri blog...

Ah, il Friuli…

| Comments

Come non sfruttare i primi giorni di sole e gli ultimi di libertà?

DSC_7331 DSC_7295 DSC_7242 DSC_7182 DSC_7149

E le altre 2/3 sul set dedicato al Friuli

Alias Method

| Comments

Need to generate random samples from a given discrete distribution? The Alias Method (wonderfully described here) comes to mind… for those who haven’t heard of it it’s a simple but powerfull $\Theta(1)$ random generator with a $\Theta(n)$ initial setup time, so… need to generate random samples from a given discrete distribution in Scala? Check out this implementation.

PS: I love github’s gist feature!

Life

| Comments

Or the game of life written in Scala with a little bit of Swing for the gui.

Let’s explore this code a little bit…

The basic idea is to visualize a Set[Coord] instances on the graphical grid and obtain, with every iteration, the new Set of alive cells.

In order to do that let’s define our beginning state inside the Life main object and create an iterable element using Iterator.iterate method..

1
2
3
4
5
6
object Life extends SimpleSwingApplication {
  val startData: Set[Coord] = Set(/* initial state */)
  val it = Iterator.iterate(Generation(startData))(_.nextGeneration)
  // setup swing window components and 
  // a runnable element to use as an "updater"
}

The Generation class is a extended Set[Coord] which is able to obtain the nextGeneration concatenating (still) alive cells with newborn cells

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Generation(val alive: Set[Coord]) extends Set[Coord] {
  // Set contract methods...

  // get all neighbors for every cell, group by cell
  // and get a tuple with Coord and neighbors count
  private val neighbors = alive.toList flatMap(_.neighbors) groupBy (identity) map { case (c, l) => (c, l.size) }
  // define a generic method to obtain a filtered selection of cells
  private def neighborhood(filter: Filter) = for (filter(coord) <- neighbors) yield coord
  // obtain new born cells 
  // (ie the ones that meet newborn filter requirements)
  private def babies = neighborhood(newborn)
  // obtain current alive cells, watch out for the "alive &" stuff...
  private def adults = alive & neighborhood(stable).toSet
  // concatenate adults with babies
  def nextGeneration = Generation(adults ++ babies)
}

Filters are defined in Generation Object as

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
object Generation {
  // case class already defines an apply() method so
  // let's only define an unapply method which
  // accepts a function((Coord, Int)) to Option[Coord]
  // as filtering logic
  case class Filter(f: ((Coord, Int)) => Option[Coord]) {
    def unapply(t: (Coord, Int)): Option[Coord] = f(t)
  }
  def apply(alive: Set[Coord]) = new Generation(alive)

  // if a cell has 3 neighbors it's ok for a new birth
  val newborn = Filter {
    case (c, 3) => Some(c)
    case _ => None
  }
  // 2 or 3 neighbors are ok...
  val stable = Filter {
    case (c, 2) => Some(c)
    case (c, 3) => Some(c)
    case _ => None
  }
}

The last interesting stuff is the implicit conversion from Tuple to Coord objects

1
  implicit def tupleToCoord(t: (Int, Int)): Coord = apply(t._1, t._2)

Now add some graphic code and here we are:

Update (04 feb): code is now stored on github

Pulizie di Primavera

| Comments

Questa volta non ci casco, è inutile promettere di seguire questo blog quando so benissimo che ci sono talmente tante cose da fare in una vita che già spazzare il pavimento di casa e portar fuori l’immondizia fanno passare in secondo-terzo-quarto piano le routinarie operazioni di igiene dovute al proprio sito personale.

D’altra parte, visto lo stato pietoso in cui versava il mio dominio, era necessario fare qualcosa… tanto per dare un segno di vita!

Innanzi tutto si imponeva un cambio di look, font decisamente troppo piccolo e magro per una lettura piacevole e riposante, tema eccessivamente bianco e troppo spazio vuoto. Non potevo, tuttavia, limitarmi alla ricerca/creazione/modifica di una skin qualsiasi per wordpress, troppa roba da scartabellare (1465 temi al momento!) e un certo malessere al pensiero di imbastire nuovamente la baracca:

  • wordpress (che ormai avevo riempito di plugin in preda al delirio della sperimentazioni);
  • database (mysql) con annesso phpmyadmin;
  • setup del pannello di amministrazione (plugin…);
  • cercare un plugin come-dico-io™ per la visualizzazione delle gallery;
  • aggiornamenti automatici;
  • uso di un editor html per scrivere i post;
  • etc etc…

Insomma, dopo svariati anni di utilizzo, e pur considerandolo uno strumento eccezionale ed estremamente flessibile, wordpress mi ha rotto. La ricerca di alternative (e nemmeno io sapevo esattamente di quale genere queste potessero essere) mi ha portato a scoprire l’esistenza di Jekill prima e di Octopress dopo… e qui ci sta una spiegazione per chi non è avvezzo a questi blogging framework per hacker (come si autodefiniscono).

Mai Portare i Filosofi a Cena

| Comments

Ovvero il problema dei filosofi a cena risolto utilizzando Scala ed Akka 2.0 (l’attuale snapshot)

(dining_philosophers.scala) download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
import akka.actor.Actor
import akka.actor.ActorRef
import akka.actor.Props
import akka.util.duration._
import scala.actors.threadpool.TimeUnit
import akka.actor.ActorSystem

sealed trait TableMessage
case class Take(philosopher: ActorRef) extends TableMessage
case class Taken(fork: ActorRef) extends TableMessage
object Eat extends TableMessage
object Think extends TableMessage
object Busy extends TableMessage
object Put extends TableMessage

class Fork extends Actor {
  import context.become

  def available: Receive = {
    case Take(philosopher) =>
      become(taken)
      philosopher ! Taken(self)
  }

  def taken: Receive = {
    case Take(otherOne) =>
      otherOne ! Busy
    case Put =>
      become(available)
    case x => println(x)
  }

  def receive = available
}

class Philosopher(left: ActorRef, right: ActorRef) extends Actor {
  import context.become
  import context.system

  def hungry: Receive = {
    case Taken(this.left) =>
      become(waiting_for(right, left))
    case Taken(this.right) =>
      become(waiting_for(left, right))
    case Busy =>
      become(denied)
  }

  def eating: Receive = {
    case Think =>
      println(self.path.name + " puts down his forks and starts to think")
      become(thinking)
      left ! Put
      right ! Put
      system.scheduler.scheduleOnce(3 seconds, self, Eat)
  }

  def waiting_for(toWaitFor: ActorRef, taken: ActorRef): Receive = {
    case Taken(toWaitFor) =>
      become(eating)
      println(self.path.name + " has taken " + taken.path.name + " and " + toWaitFor.path.name)
      system.scheduler.scheduleOnce(3 seconds, self, Think)
    case Busy =>
      become(thinking)
      taken ! Put
      self ! Eat
  }

  def thinking: Receive = {
    case Eat =>
      become(hungry)
      left ! Take(self)
      right ! Take(self)
  }

  def denied: Receive = {
    case Taken(fork) =>
      become(thinking)
      fork ! Put
      self ! Eat
    case Busy =>
      become(thinking)
      self ! Eat
  }

  def receive = {
    case Think =>
      become(thinking)
      system.scheduler.scheduleOnce(1 seconds, self, Eat)
  }
}

object Dining extends App {
  val system = ActorSystem("DiningTable")
  val forks = for (i <- 1 to 5) yield system.actorOf(Props[Fork], "fork" + i)
  val philosophers = for {
    (name, i) <- (List("Pluto", "Socrates", "Aristotle", "Pythagoras", "Zeno").zipWithIndex)
  } yield system.actorOf(Props(new Philosopher(forks(i), forks((i + 1) % 5))), name)
  philosophers.foreach(_ ! Think)
}

ispirato da questa soluzione, ossia da questa

Eppure…

| Comments

Non si può negare che il male esista; occorre vederlo e prendere delle precauzioni. Ma anche se esiste, non è una buona ragione per non vedere altro.

Purtroppo, ci sono persone che si compiacciono nel male come se fosse per loro un nutrimento: vanno matti per gli scandali, le catastrofi, le sordidezze…
Sostengono di parlare del male per denunciarlo, per combatterlo.
No, è falso; ne parlano perché lo amano, e ne godono. Senza il male si annoierebbero, non avrebbero niente da dire, niente da scrivere. Bisognerebbe abituare i bambini sin da piccoli a interessarsi di preferenza a tutto ciò che è bello, buono, nobile, puro. È talmente più benefico per la loro formazione! Del resto, è questa la vera pedagogia: sforzarsi di nutrire nei bambini l’amore per tutto ciò che esiste di meglio, perché solo l’amore per la bellezza, per la bontà e per la giustizia permette veramente di neutralizzare il male in se stessi e negli altri.

Omraam Mikhaël Aïvanhov

Mi fa venire in mente certa parte dell’Italia… ma non solo per (s)fortuna

Essere Sviluppatori Oggi

| Comments

Dunque, spiegatemi se ho capito bene, io mi giro un attimo e succede che Oracle (proprio quella sudiciona dell’omonimo database) si compra Sun (e quindi MySql) mandando a puttane OpenOffice e Java (con tanto di stupida causa contro Google) e nessuno dice un tubo, se MS avesse provato a comprare un vendor linux sarebbero stati pronti a farsi saltare in aria 1000 pinguini imbottiti di tritolo, qui il silenzio e la fuga dei dipendenti…

Non paghi di tutto questo casino Apple decide che è ora che Java e Flash si arrangino e che l’utente non deve averli nel suo pc splendidamente integrati come sempre era stato; così può propinare l’app store anche sulle macchine di classe desktop/notebook, a questo punto togliamo la possibilità di installare applicazioni da dvd, che ne dite? Il futuro è un’unica famiglia di iPad con/senza telefono, con/senza tastiera fisica e col monitor più o meno grande? Wow…

In tutto questo MS decide che effettivamente Vista era una crosta senza fine e lancia 7, e, visto che il mondo si sta spostando verso i sistemi operativi mobile (che dei pc non gliene fotte più a nessuno per muovere i soldi veri), capisce di dover cestinare quella schifezza di Windows Mobile e scriverne uno che sia vagamente utilizzabile ed in linea con gli standard attuali e ora, con solo un paio d’anni di ritardo, si getta anche lei nella mischia. I miei personali auguri ma mi sa che non ci sono idee chiare li dentro (del resto Ballmer non ha ancora capito qual è il lavoro per cui viene pagato…)

Abbiamo parlato di mobile? E il supergigante Nokia? Che ha fatto di bello? Comprato Symbian, lo ha rilasciato open, lo ha fatto morire, ne ha ripreso lo sviluppo, l’ha rinnegato e poi ha deciso che il futuro è MeeGo. Bravi, se continuate così persino l’LG vi mangerà il culo nella fascia degli smartphone, arrendetevi e ricacciate in gola l’orgoglio ve ne prego che l’hw lo fate bene :( (persino Sony si è arresa e sembra sulla scia di una certa ripresa…)

Nel mentre Google continua a muoversi in modo apparentemente casuale, comprando aziende di cui non sa cosa farsene (salvo poi riuscire a farle fruttare lo stesso :) ), producendo un sistema operativo da utilizzare su device connesse alla rete, e interpretando correttamente (almeno secondo me) la prossima lotta nel panorama aziendale informatico: connettere qualsiasi cosa alla rete e usarla per vendere/distribuire/promuovere qualcosa (tipicamente merda ma ci son tante cose anche carine, credo).

Apple lo sta facendo da più tempo, Google lo sta facendo su più fronti, MS sta cercando di capirlo, chissà cosa ne tireranno fuori.

E se vi state chiedendo cosa centri la parte iniziale su Sun è presto detto, il backend di tutto questo marasma di roba (a parte per MS, forse) in che linguaggio credete che sia stato e sarà scritto? Maremma che casino, per fortuna me ne son tirato fuori… è dura essere sviluppatori oggi…

P.S. se il discorso vi pare sconfusionato è perché è stato scritto di getto, sono certo che chi deve capire, tuttavia, capirà

Comunicazione di Servizio

| Comments

Siamo di nuovo in piedi, risolti dei “piccoli” problemi di funzionamento del tutto.

Shit happens, capita anche nelle migliori famiglie :)