Best Organized Kitchen Ever?

In Scala I rarely use annotations. However when you need to interoperate with a framework which relies on annotations you need use them. So lately I wanted to store some simple case classes with JPA. As you know, JPA relies quite heavily on annotations, unless you move everything out to XML descriptors.

I wanted to store something like this:

@Entity
case class MyStoredData(userName:String,
                         realName:String,
                         @Id id:Long =0) {
  // JPA requires a parameter-free constructor
  def this() = this("","")
}

Unfortunately this results in exceptions like the one below. Basically the annotation is not placed on the ‘field’ but rather on the parameter of the constructor.

Caused by: com.versant.jpa.enhancer.exceptions.MissingIdException: missing ID annotation or mapping for info.gamlor.vjpa.model.MyStoredData
	at com.versant.jpa.enhancer.JpaClassEnhancer.enhance(JpaClassEnhancer.java:123)
	at com.versant.jpa.enhancer.JpaClassEnhancer.enhance(JpaClassEnhancer.java:50)
	at com.versant.jpa.enhancer.JpaClassTransformer.transform(JpaClassTransformer.java:51)
	at sun.instrument.TransformerManager.transform(TransformerManager.java:169)
	at sun.instrument.InstrumentationImpl.transform(InstrumentationImpl.java:365)

Now you actually can specify on which elements such an annotation is added. So in this situation we can tell the Scala to ensure that the annotation is also placed on the id field:

@Entity
case class MyStoredData(userName:String,
                         realName:String,
                         // ensure that the field is also annotated
                         @(Id @field) id:Long =0) {
  // JPA requires a parameter-free constructor
  def this() = this("","")
}

This will fix the issue. There are more possible targets, like Scala accessors and Java Beans getter/setters for @BeanProperty annotated fields. Take a look at the documentation here.

That’s all. Nothing more to tell =)

Relational Stuff fits Scala well

A while back I needed to read some data from a relational database in Scala. What I wanted was a small library, which removes most of the JDBC boiler plate, but not a full blown ORM. I ended up using is ScalaQuery.

This library gives you a thin, rational layer on top of JDBC. This is how it works. First you define a ‘table’. This is done extending a table class and adding field definitions to it:

val ApiKeys = new ExtendedTable[(String, String)]("googleApiKeys") {
	def deviceId = column[String]("deviceId", O.PrimaryKey)

	def apiKey = column[String]("apiKey")

	def * = deviceId ~ apiKey
}

Afterwards you need to create a database instance:

val database: Database = Database.forURL("jdbc:h2:~/apiKeyStore", driver = "org.h2.Driver")

To do an operation we need a transaction / session. On way to create such a session is to use the withSession method. Basically all operations require a session. We can manually pass the session to the methods. Or we can declare an implicit session which is used. For example the built in thread local session:

// We use the thread local session management
// So we import this implicit parameter which returns the current session
// Of course we pass any other session / use our own implicits
import org.scalaquery.session.Database.threadLocalSession


// and we do stuff in our session
database withSession {
  // do stuff
}

For example we can create the database schema:

database withSession {
    ApiKeys.ddl.create
}

Now to the important part: We can query and update data with our table object. The cool thing is that we just can use the Scala for-construct to do so. The library will transform our code into the appropriate SQL statement. Everything lives in the ‘Scala’ world, no strings and casts etc. are required. Also not that some imports are required for these API features:

// Imports for the query API
import org.scalaquery.ql.extended.H2Driver.Implicit._
import org.scalaquery.session.{Session, Database}
import org.scalaquery.ResultSetInvoker
import org.scalaquery.simple.StaticQuery
import org.scalaquery.ql.Query


// Query
val devicesByApiKey = for {
	a <- ApiKeys if a.deviceId.like(deviceId)
} yield a.apiKey

// Do stuff with the result
devicesByApiKey.foreach(i=>doStuff(i))

We also can insert and update tables:

val devicesByApiKey = for {
	a <- ApiKeys if a.deviceId.like(deviceId)
} yield a.apiKey

devicesByApiKey.firstOption match {
	case None => {
	  ApiKeys.insert(deviceId, googleKey)
	}
	case Some(_) => {
	  query.update(googleKey)
	}
}

My Opinion & State of the Library

I really like the approach of this library. It is lightweight, close the SQL-metal and yet it blends perfectly with the Scala code. It really doesn’t feel like you entering into a new domain when talking to the database. It only surfaces operations which work in SQL and doesn’t do any operations behind the scenes. For many use cases this works way better than heavy weight ORM frameworks.

However I have to point out that many features are not there and there doesn’t seem any active development going on. For example you cannot check if a table already exists before calling the ‘create schema’ method. I also miss a nice method for using raw SQL in case you need a missing feature.

So right now I only would use it for pet projects, or when you are willing to invest your time to patch and improve things.

Machinae Supremacy의 시작

이거 내가 Machinae Supremacy의 노래 몇개 좋아해요:

Gimme More: Britney Spears의 노래 커버 이고 재미있어요:

Indiscriminate Murder Is Counter-Productive: 이 노래의 가사 재미있어요. 그래서 주의하고 들어주세요:

Force Feedback: 노래의 비디오 있어요:

Machinae Supremacy's Beginning

Here are a few Machinae Supremacy songs I like:

Gimme More: It’s a Britney Spears cover:

Indiscriminate Murder Is Counter-Productive: The lyrics of this song are fun, so listen carefully:

Force Feedback: Well it has a official video:

저는 공포-영화 정말 좋아해, 그래서 이 공포-드라마 (위키백과) 봤을 때 봐야 돼요. 이 드라마에서 윤하나는 여동생 죽을 때부터 동생의 귀신 있다고 만나요. 그리고 시작 귀신 많아 지고  있다. 정말, 윤하나는 너무 뭇어워서 도움 필요해요. 그래서 프로파일러 신류 도워요. 근데 신류 하고 귀신가 나쁜 사람을 죽이고 싶어요.

귀신이 항상 얘기해요

이 드라마는 좋아세요? 괜찮아요. 근대 저는 이야기가 조금 이해 못하고 조금 심심해요.

제 평가: (2/5)

Ok, here‘s the longer version my little review of Soul (혼)(Hancinema), a horror drama. I personally love Horror movies, so when I stumbled upon Soul I had to check it out.

It’s about Yoon Hana whose sister dies and shortly after starts to appear as ghost. Later on Yoon Hana starts to see more and more ghosts. Of course she is scared to death and seeks for help. So Shinryu, a Crime-Profiler, starts to help her. But Shinryu and the ghost also have other plans: To kill bad guys.

Ghosts always tell stories

Well the series starts with this stereo typical scary, black haired ghost girl stuff. At the beginning it is quite confusing and cuts between different flashbacks which make no sense what so ever. However after a few episodes a story starts to crystallize, which is actually kind of neat. It also moves away from the horror theme start to become more thriller style. Unfortunately the story is told very slowly, so it gets somewhat boring sometimes. I think this series would be much better with faster storytelling and more focus on the thriller elements.

Now is it scary? No not really, but I didn’t expect that from a TV series. But it has some nice atmospheric and cool scenes. I also have to mention one very strange scene from the beginning, the suicide-scene. Well, this scene is strange to me because it nearly celebrates the suicide by matrix-style slow-motion camera work. Quite unusual to put that much focus on this kind of scene.

All in all, Soul is all right, but not all that great. I recommend other series  Jekyll, Dead Set etc. with a horror theme. Even some recent Doctor Who episodes have a moody horror atmosphere to them.

Star-O-Meter: (2/5)

The trailer is strange, because I think that many scenes are not present in the series:

Akka 2.0 is available as a preview version. Here’s a short guide how to get it to run on Android. This pretty much work in progress. Maybe someone else has even has a better strategy. Let me know if that’s the case=). Also I didn’t do much with Akka 2.0 on Android yet, so maybe there are major issues yet to discover =).

Let's master this Akka-beast, little Android =)

In general I just assume that you have a working Scala build and know how to include new Scala libraries. And I also assume that you are using Proguard to shrink the jar file. I use a build based on this. In case you are having trouble, just ask for help =).

First add the Akka 2.0 M3 jar-file to the project (The M2 bits won’t work). Make sure that it is in your directories of libraries which are compacted by Proguard. Unfortunately you will get tons of warnings by Proguard about classes which couldn’t be found, because they are not part of the Android platform. These are three categories of classes which are not available:

• ‘ akka.util.JMX’: There is no JMX on Android.
• ‘sun.misc.Unsafe’: Well at first sight Android doesn’t have this implementation-detail class. Luckily it actually does have it (at least in newer versions), but it’s only available at runtime. The jars which you compile against do not have this class.
• ‘org.omg.CORBA’-stuff. The Akka library has a UUID implementation which implements some interfaces from CORBA.

So it is time for some Proguard trickery to get rid of warnings.

Bye Bye JMX

Well there is definitely no JMX on Android. So I just excluded the JMX stuff from Akka:

## No JMX for Android
-dontwarn akka.util.JMX*

Ignoring ‘sun.misc.Unsafe’ Warnings

The next step is to configure Proguard to ignore the ‘sun.misc.Unsafe’ warnings. It is there on the device (If not, please tell me).

## Unsafe is there at runtime
-dontwarn sun.misc.Unsafe
-keep class sun.misc.Unsafe{
    *;
}

Fixing the CORBA Stuff

## UUID helpers are not used
-dontwarn com.eaio.uuid.**

Remove the FSM Forward Reference

The core Akka library contains a forward reference to its finite state machine (FSM) implementation. In a usual class loader environment this doesn’t matter, since classes are lazily loaded. However Proguard is going to bitch about it. So in case you are not using the FSM library remove that reference with Proguard:

## No Finate State Machines Support needed
-dontwarn akka.actor.FSM

Keep Important Classes

Also we need to keep some classes which are loaded at runtime. Maybe there are more required for some features, just watch for class loader errors. These are the ones you need for sure:

## Stuff referenced at runtime
-keep public class akka.actor.LocalActorRefProvider {
   public <init>(...);
}
-keep class akka.event.Logging*
-keep class akka.event.Logging$LogExt{
    *;
}

Work Around the Reference Configuration Issue?

I’m not sure what exactly the issue is here and probably I’m doing something wrong. At least with my setup Akka cannot find its internal reference.conf resource file. Looks like resources are only loaded from the *.apk file? Anyway, for now I just copied the reference.conf file from the Akka source code to my project (Or do it with a build task). Then everything runs.

Conclusion

Yes, it is a little hairy to get Akka 2.0 to run on Android. I certainly will work a little more on it. And in case it gets too bad I’ll do a shallow fork of Akka .

DJs From Mars는 유명한 팝 노래가  하우스 음악를 되는 걸 해요. 그래서 저 하우스 음악아랑 알려진 노래가 매우 재미있어요.

그리고 난 DJs From Mars의 한번 음악-믹스 들어봤을 때  하우스-음악을 진짜 좋아해요.

DJs From Mars

여기 음악-믹스가 하나 있어요:

There are many remixers and mashup creaters. And so DJs From Mars are one of the best remix makers. On Souncloud they monthly upload a music-mix. That music-mix has always new remixes and mashups.

DJs From Mars turn popular pop songs into house music. That house music with known songs is fun.

And after listening to their mixes I started to really like House music.

There such a music mix above.

Translation of the Comic:

Happy-guy: I like Pop music but don’t like House music.
Evil-guy: I like House Music and Noise. More Noise please.
Happy-guy: Should we make a Remix together?
Evil-guy: Allright.
Together: We are a good team!

• 검색엔진하고, 태그 구름하고,  그룹 있어서 , 새로운 음악 발견하기 쉬워요.
• 댓글 쓰기 쉬워요. 그리고, 어떤 시간에 댓글 할 수 있어요.
• 업로드하고 공유하기 쉬워요.
• 트위터처럼  음악가를 팔로우해요.
• 광고가 없어요.

당신은 전자 음악이 좋아서  Soundcloud을 봐보세요! 그리고 내 믹스 테이프기 Soundcloud에 있어요 =).

다음 블로그 포스트에 난 좋은 Soundcloud의 사람 얘기할 거에요.

Soundcloud 끝내줘요

I really like Soundcloud. Soundcloud is a music website where users can listen and upload music. There are many good electronic music composers, remixers and mashup creators on Souncloud. And Soundcloud itself has some nice featueres:

• It is easy to discover music with its search, tag-clouds and group featuers.
• Commenting is easy. And you even can leave a comment at a particular time.
• Uploading and sharing is easy.
• Like Twitter, you can follow artists.
• There are no ads.

When you like electronic music you should check out Soundcloud. And my mixtapes are on there!

In the next blog post I’m going to talk about some of my favorite people on Soundcloud.

Ramyun, yummie

Yes, Boy Ramyun Shop doesn’t need a plot description, it is a cliché driven romantic-comedy. I mean really cliché driven. This show goes along with every cheesy and formula plot point. Basically our two main characters first meet in an ‘accident’-situation. Later on they meet again in a more permanent situation. They argue and hate each other, but can’t really let go of each other and fall in love. Finally they live happily ever after. Oooooooohhhh, how cute.

Given this kind of show, there are countless cheesy and silly scenes. The characters are mostly naïve and fulfill some stereotype. Additionally there is a tons of overacting. Especially the lead actress overacts the shit out of her role. When you think this isn’t enough, they sometimes add small cartoon animations and comic-sound effects to underline scenes. All in all, it is way over the top.

This all sounds negative, and it kind of is. However I nevertheless love ‘Flower Boy Ramyun Shop’. For me it has the exact right balance of ‘over-the-topless’, silliness, foreseeable jokes and enjoyable badness. It is somewhat a guilty pleasure. What makes this show it work for me are the likable characters. I liked all characters, including the ‘asshole’-characters. I don’t mind stereotype characters as long as I enjoy them =).

Can I recommend it? Rationally: NO WAY. Had I fun watching it? HELL YES. It’s one off the funniest series I’ve watched for quite a long time. I think this series has a sharp line between being liked and hated. If you like over-the-top stuff, watch the first (half) episode and decide. Or maybe your already put off by the scenes I’ve liked below =)

Rational-Star-O-Meter: (2/5)
Enjoyment-Star-O-Meter: (4/5)

Trailers: Again, there are no good trailers around =(

Dead-boring English subtitled trailer:

Super silly over the top scene. No subtitles, but gives a better impression. (Well, there are also normal scenes =) ):

Void Is Not Cool Enough

In my code I often end up doing something like this:

class Example
{
	// Stuff like transactions, run in contexts, binding methods etc etc.
	public T WithSomeContext<T>(Func<T> runInContext)
	{
		// do magic and stuff
		var result = runInContext();
		// do other stuff
		return result;
	}

	// Doublicate to also accept Void returns
	public void WithSomeContext(Action runInContext)
	{
		WithSomeContext<object>(() =>
			{
				runInContext();
				return null;
			});
	}

	public void UseIt()
	{
		var valueOne = 1;
		var valueTwo = 2;
		// with return value
		var sum = WithSomeContext(() => valueOne + valueTwo);

		WithSomeContext(() => Console.WriteLine("Hi-There"));
	}
}

That’s just boilerplate which I really don’t need. In many other languages, for example Scala, this is handled more elegantly. The void-type (often called Unit) is a regular type. And void/unit values just represent ‘void/unit‘:

class Example{

  def withContext[T](runInContext:()=>T):T ={
            // do magic and stuff
            val result = runInContext();
            // do other stuff
            return result;
  }
  
  // no need for another method. 
  // Our withContext also can accept 'void'-returns aka Unit 

  def useIt() {
    val valueOne = 1;
    val valueTwo = 2;
    
    var sum = withContext(() => valueOne + valueTwo);

    withContext(() => println("Hi-There"));

  }
}

Yes, I know, it’s not the end of the (programming) world. There are tons of other issues which lead to more boiler-plate. Anyhow, it is such a little thing and still so god damn annoying. God help us that no new programming includes the same little weakness =).

한글 쉬워요!

Ah yes, I’m learning Korean. How the hell did I end up learning that? Well I wanted to learn something non-technical like a language for a long time. First wanted to relearn French or learn something easy (close to German/English) like Dutch, but never could motivate me. Then I thought that I should learn something completely different, like Russian, Chinese or whatever. Of course I never started to do it.

So how did I end up with Korean? Well that one kind of sneaked onto me. While watching Korean movies and stuff I started to wonder what strange writing system they use. It didn’t look anything like Chinese or Japanese, nor like anything ‘European’-like. So one day I looked it up and learned the basics of the Hangul writing system. And because Hangul is damn easy I kept going. Of course a writing system without words is useless, so I started to learn the first basic words. And I kind of never stopped learning. Now I find it fun to learn some bits here and there and I keep going.

The original purpose of this blog was to practise English, so now I come back its roots and start practising Korean here =). For the readers sake I will add a English translation to each post. Also because my Korean is probably so wrong that it is not understandable XD. Of course the content will be very trivial, since I’m a beginner.

Comic-Content

On the Board: Hangul ‘characters’ with there ‘pronounciation’. Don’t use this as a reference XD

The Guy: What is Hangul? Learning Korean was a bad idea!