Scala - 컬렉션을 병렬로 실행하고 정렬된 결과를 얻기

Scala 의 좋은 점이 기본적으로 병렬 처리를 수행할 수 있도록 병렬 형태의 컬렉션 자료구조를 지원하고, 일반 컬렉션도 .par 를 이용하여, 병렬 처리를 지원하는 자료구조로 변환할 수 있습니다.

다만 아쉬운 점이라고 한다면, 병렬 처리 자체가 정렬을 지원하지 않기 때문에, 정렬된 순서대로 결과가 나오지 않는다는 단점이 있습니다.

.NET에는 .asParallel() 외에 .asOrdered() 가 있어, 병렬 처리를 하면서 정렬된 결과를 얻을 수 있습니다.

Scala에서는 아쉽게 지원되지 않으므로, 한 번 더 처리 해 줘야 합니다.

다음과 같이 처리해야 할 정보를 받아 mapper 함수를 이용하여 작업을 처리한다고 한다면, 단순히 map(mapper(_) 만 수행하면 되겠지만, 정렬을 수행하기 위해, 입력 변수도 같이 저장하여, 정렬을 수행할 수 있도록 한 후, 정렬 후에 Tuple에서 원하는 결과만 빼서 전달하는 것입니다.

	def mapAsOrdered[T <: Ordered[T], V](items: Iterable[T], mapper: T => V): Iterable[V] = {
	items.par
	.map(item => (item, mapper(item)))
	.toList.sortWith(_._1 < _._1)
	.map(_._2)
	}

view raw Parallels.scala hosted with ❤ by GitHub

뭐 입력 자체가 정렬이 안된 경우도 있을 수 있고, 입력값 자체가 map 형태라면 좀 달라져야 하지만, 유사한 로직으로 해결이 가능할 것입니다.

Java로도 유사한 코드를 만들 수 있지만, Scala 가 더 편하네요^^

[강추] Google Guava 자료

Google Guava 를 더 파보니, .NET TPL 의 Task Chain 기능도 있네요. ㅋ

MoreExecutors  도 있고 흠...

Guava Wiki 보는 것도 좋지만, 실제 예제 소스가 아주 풍부하게 많은 자료가 있어 소개합니다.

Google guava - almost everything you need to know from Tomasz Dziurko

후~ 저도 많이 안다고 생각했는데, 유용한 걸 더 찾을 수 있었네요^^ 역시 아는 만큼 보이나봅니다.

Java Byte code 생성을 이용하여, Reflection 대체하기

아주 유명한 iBatis 같은 것도, 처음에는 Reflection을 통해 클래스의 동적 생성,  필드 값 설정 등을 실행했다가, 성능때문에 Java Byte Code 를 동적으로 생성하게 하여, 생성된 코드를 동적으로 실행하도록 변환했던것으로 기억합니다.

.NET 에서도 Reflection 의 성능때문에 Dynamic Method 라는 기법을 이용하여 동적으로 ILCode 를 생성하고,  그것을 실행하면 기존 Reflection 보다 4~100배 이상으로 빨라집니다.

이런 좋은 기능이 있는데, 안쓰면 바보겠죠? Java로 넘어 온 후, 실제 이런 기능의 필요성을 많이 못 느낄 정도로 iBatis 나 Hibernate 만을 사용했지만, 점점 JDBC 로우 레벨로 내려가다 보니,  꼭 필요하게 되는군요...

예를들어 객체 정보를 Map 으로 표현하고, Map으로 표현된 정보를 다른 객체 정보에 설정하려고 하는 기능 ( Mapper ) 는 상당히 많이 사용되기도 합니다. Model Mapper 라는 훌륭한 라이브러리가 있지만,  모든 것을 다 제공하는 게 아니고, 변형해서 쓰고자 하는 경우가 있어, 찾아 봤습니다.

여러가지 라이브러리가 있었지만, 작고 심플한 라이브러리를 찾다가 reflectasm 이란 놈을 발견했습니다. 

소스를 보니 제가 원하는 딱 그 것이였습니다. byte code generation 을 통해 성능을 향상시킨다^^ 캬... Good 

라이브러리를 가지고, 기존 .NET 코드와 유사하게 골격을 갖춰 봤습니다.

DynamicAccessor 라고 수형정보만 제공하면, 객체의 생성,  필드 정보 조회/수정, 메소드 실행 등을 할 수 있습니다.

	/**
	* 동적으로 객체의 속성, 메소드에 접근할 수 있는 접근자입니다.
	* User: sunghyouk.bae@gmail.com
	* Date: 13. 1. 21
	*/
	@Slf4j
	public class DynamicAccessor<T> {
	private final Class<T> targetType;
	private final ConstructorAccess<T> ctorAccessor;
	private final FieldAccess fieldAccessor;
	private final MethodAccess methodAccessor;
	private final List<String> fieldNames;
	private final List<String> methodNames;
	public DynamicAccessor(Class<T> targetType) {
	Guard.shouldNotBeNull(targetType, "targetType");
	if (log.isDebugEnabled())
	log.debug("");
	this.targetType = targetType;
	this.ctorAccessor = ConstructorAccess.get(this.targetType);
	this.fieldAccessor = FieldAccess.get(this.targetType);
	this.methodAccessor = MethodAccess.get(this.targetType);
	this.fieldNames = Lists.newArrayList(fieldAccessor.getFieldNames());
	this.methodNames = Lists.newArrayList(methodAccessor.getMethodNames());
	}
	@SuppressWarnings("unchecked")
	public <T> T newInstance() {
	return (T) ctorAccessor.newInstance();
	}
	@SuppressWarnings("unchecked")
	public <T> T newInstance(Object enclosingInstance) {
	return (T) ctorAccessor.newInstance(enclosingInstance);
	}
	public String[] getFieldNames() {
	return fieldAccessor.getFieldNames();
	}
	public String[] getMethodNames() {
	return methodAccessor.getMethodNames();
	}
	public Object getField(Object instance, String fieldName) {
	return fieldAccessor.get(instance, fieldName);
	}
	public void setField(Object instance, String fieldName, Object nv) {
	fieldAccessor.set(instance, fieldName, nv);
	}
	public void setFieldBoolean(Object instance, String fieldName, boolean nv) {
	fieldAccessor.setBoolean(instance, fieldAccessor.getIndex(fieldName), nv);
	}
	public void setFieldByte(Object instance, String fieldName, byte nv) {
	fieldAccessor.setByte(instance, fieldAccessor.getIndex(fieldName), nv);
	}
	public void setFieldChar(Object instance, String fieldName, char nv) {
	fieldAccessor.setChar(instance, fieldAccessor.getIndex(fieldName), nv);
	}
	public void setFieldDouble(Object instance, String fieldName, double nv) {
	fieldAccessor.setDouble(instance, fieldAccessor.getIndex(fieldName), nv);
	}
	public void setFieldFloat(Object instance, String fieldName, float nv) {
	fieldAccessor.setFloat(instance, fieldAccessor.getIndex(fieldName), nv);
	}
	public void setFieldInt(Object instance, String fieldName, int nv) {
	fieldAccessor.setInt(instance, fieldAccessor.getIndex(fieldName), nv);
	}
	public void setFieldLong(Object instance, String fieldName, long nv) {
	fieldAccessor.setLong(instance, fieldAccessor.getIndex(fieldName), nv);
	}
	public void setFieldShort(Object instance, String fieldName, short nv) {
	fieldAccessor.setShort(instance, fieldAccessor.getIndex(fieldName), nv);
	}
	public Object getProperty(Object instance, String fieldName) {
	String methodName =
	(methodNames.contains(fieldName)) ? fieldName : "get" + getPropertyName(fieldName);
	return invoke(instance, methodName);
	}
	public void setProperty(Object instance, String fieldName, Object nv) {
	String methodName =
	(methodNames.contains(fieldName)) ? fieldName : "set" + getPropertyName(fieldName);
	invoke(instance, methodName, nv);
	}
	public Object invoke(Object instance, String methodName, Object... args) {
	return methodAccessor.invoke(instance, methodName, args);
	}
	private static final String getPropertyName(String filedName) {
	return filedName.substring(0, 1).toUpperCase() + filedName.substring(1);
	}
	}

view raw DynamicAccessor.java hosted with ❤ by GitHub

동적으로 특정 수형의 속성이나 메소드 실행하는 것은 환경설정이나 사용자 매크로 등을 파싱하여 실제 클래스를 수행하게 할 때 아주 유용합니다.

다음 코드는 DynamicAccessor 를 생성해주는 Factory입니다. 굳이 factory를 만든 이유는 DynamicAccessor 생성 비용이 일반 클래스의 생성 비용에 비하여 상당한 비용이 들어가므로, Cache 를 이용하여, 재활용하자는 의미가 큽니다.  Cache는 google guava의 LoadingCache 를 사용한 이유는  Cache 자체적으로 항목들을 관리할 수 있어, 코드량 및 실수가 적어지는 것이 장점입니다.

	/**
	* {@link DynamicAccessor} 의 생성자입니다.
	* User: sunghyouk.bae@gmail.com
	* Date: 13. 1. 21
	*/
	@Slf4j
	public class DynamicAccessorFactory {
	private static final CacheLoader<Class<?>, DynamicAccessor> loader;
	private static final LoadingCache<Class<?>, DynamicAccessor> cache;
	static {
	loader = new CacheLoader<Class<?>, DynamicAccessor>() {
	@Override
	@SuppressWarnings("unchecked")
	public DynamicAccessor<?> load(Class<?> type) throws Exception {
	return new DynamicAccessor(type);
	}
	};
	cache = CacheBuilder.newBuilder().build(loader);
	}
	@SuppressWarnings("unchecked")
	public static <T> DynamicAccessor<T> create(Class<T> targetType) {
	try {
	return (DynamicAccessor<T>) cache.get(targetType);
	} catch (ExecutionException e) {
	if (log.isErrorEnabled())
	log.error("DynamicAccessor 를 생성하는데 실패했습니다. targetType=" + targetType.getName(), e);
	return null;
	}
	}
	public static void clear() {
	synchronized (cache) {
	cache.cleanUp();
	}
	}
	}

view raw DynamicAccessorFactory.java hosted with ❤ by GitHub

마지막으로 DynamicAccessor 를 테스트하는 코드입니다. (reflectasm 에 성능 측정 코드가 있어 굳이 만들지 않았습니다)

	@Slf4j
	public class DynamicAccessorTest {
	@lombok.Getter
	@lombok.Setter
	static class User {
	private String email;
	private Double age;
	public User() {}
	public void includeAge(int delta) {
	age += delta;
	}
	}
	@Test
	public void dynamicInstancing() {
	DynamicAccessor<User> userAccessor = DynamicAccessorFactory.create(User.class);
	Assert.assertNotNull(userAccessor);
	Object user = userAccessor.newInstance();
	userAccessor.setProperty(user, "email", "sunghyouk.bae@gmail.com");
	userAccessor.setProperty(user, "age", 110.0);
	Assert.assertEquals("sunghyouk.bae@gmail.com", userAccessor.getProperty(user, "email"));
	Assert.assertEquals(110.0, userAccessor.getProperty(user, "age"));
	}
	}

view raw DynamicAccessorTest.java hosted with ❤ by GitHub

Google Guava 소개 자료

Java 용 필수 라이브러리 중에서도 필수인 Google Guava 에 대한 소개 자료 몇개를 소개합니다.
제가 본 것 중에 가장 정리가 잘 되어 있고, 발표자료지만 머리에 쏙쏙 들어오게끔 예제 코드도 잘 만들어진 소개자료 들입니다.

1. Google Guava & Eclipse Modeling Framework - Mikael Barbero

Google Guava & EMF @ GTUG Nantes from mikaelbarbero

2. Guava by Example

다른 자료들도 많고, Guava 공식 사이트 Wiki 에도 많은 자료가 있습니다.
Java의 부가적인 코드량을 많이 줄이고, 좋은 품질의 Java 코드를 작성할 수 있는 Guava 를 많이 썼으면 합니다.

SubCut - Scala 용 Dependency Injection Framework

Java에는 Spring Framework 과 Google Guice 가 있지만, Scala 에는 특별히 DI Framework이 없는 줄 알았습니다. mix-in과 cake pattern 을 이용하여, 직접 구현하면 되니 굳이 따로 제공할 필요가 없다는 주장도 있을 정도였습니다만... 전문적인 Scala 용 Dependency Injection Framework 이 있네요^^

SubCut - Dependency injection framework for Scala

라고 2011년 부터 유명했군요... 전 이제 최근에야 알았습니다.

아래는 SubCut을 소개한 Slide 자료입니다.  이렇게도 구현할 수 있구나 감탄이 드네요^^

Scala 프로젝트를 할 때는 Spring이나 Guice 말고 SubCut을 사용해 봐야겠습니다.

Scala 의 reflection 을 이용한 객체 생성

리플렉션을 공부할 때, 가장 먼저 해보는 것이 수형을 이용하여 기본 생성자를 통한 객체를 생성해 보는 것입니다.
java에서는 당연히 가능하고, 아주 쉽습니다. java 의 generic이 . NET과는 달리 JVM 상에서는 타입을 지워버리는 (erasure) 특성때문에 적응하는데 좀 애를 먹었습니다. ㅋㅋ

	public static <T> T createInstance(Class<T> clazz) {
	Guard.shouldNotBeNull(clazz, "clazz");
	if (log.isDebugEnabled())
	log.debug("수형 [{}] 의 새로운 인스턴스를 생성합니다...", clazz.getName());
	try {
	return (T) clazz.newInstance();
	} catch (Exception e) {
	if (log.isWarnEnabled())
	log.warn(clazz.getName() + " 수형을 생성하는데 실패했습니다.", e);
	return null;
	}
	}

view raw ActivatorTool.java hosted with ❤ by GitHub

그럼 Scala에서는? 다행히 Scala 2.10.0 부터는 scala.reflect.runtime.unverse.TypeTag 로 더 많은 기능을 제공하지만, 기존 2.9.2 버전에서도 지원하는 scala.reflect.ClassTag 를 이용하면 java와는 달리 .NET처럼 수형을 제공하지 않아도 동적으로 수형을 알아낼 수 있더군요.

	/**
	* Generic 수형의 클래스에 대해 기본 생성자를 통한 인스턴스를 생성합니다.
	*/
	def newInstance[T: ClassTag](): T = {
	classTag[T].runtimeClass.newInstance().asInstanceOf[T]
	}

view raw ScalaReflects.scala hosted with ❤ by GitHub

와 같이 기본 생성자를 가진 클래스는 손쉽게 생성할 수 있습니다.
좀 더 나가서 기본 생성자 이외에 인자가 있는 클래스의 경우 인자를 주고 생성하는 경우는 어떨까? 제작해 보았습니다.

	/**
	* Generic 수형의 클래스에 대해 지정된 생성자 인자에 해당하는 생성자를 통해 인스턴스를 생성합니다.
	*/
	def newInstance[T: ClassTag](initArgs: Any*): T = {
	if (initArgs == null || initArgs.length == 0)
	return newInstance[T]()
	val parameterTypes = initArgs.map(getClass(_)).toArray
	val constructor = classTag[T].runtimeClass.getConstructor(parameterTypes: _*)
	constructor.newInstance(initArgs.map(_.asInstanceOf[AnyRef]): _*).asInstanceOf[T]
	}

view raw ScalaReflects.scala hosted with ❤ by GitHub

인자가 있는 경우는 인자로부터 수형을 추출하여, 해당 수형들을 인자로 받을 수 있는 생성자를 찾습니다.
추출한 생성자에게 인자들을 제공하여 생성하면 됩니다.


여기서 문제가 발생했습니다... java의 primitive type인 boolean, char, byte, short, int, long, float, double 이 문제였습니다. Scala가 boxing, unboxing 을 최소화하기위해 scala.Int, scala.Long 등의 수형을 정의하여 자동으로 (implicit) 하게 변환이 되도록 하였습니다. 이러한 기능으로 JVM 에서 구현될 때 scala.Int, scala.Long 등을 java 의 primitive type 으로 매칭시켜줘야 합니다.

	def asJavaClass(x: Any): Class[_] = x match {
	case x: scala.Boolean => java.lang.Boolean.TYPE
	case x: scala.Char => java.lang.Character.TYPE
	case x: scala.Byte => java.lang.Byte.TYPE
	case x: scala.Short => java.lang.Short.TYPE
	case x: scala.Int => java.lang.Integer.TYPE
	case x: scala.Long => java.lang.Long.TYPE
	case x: scala.Float => java.lang.Float.TYPE
	case x: scala.Double => java.lang.Double.TYPE
	case _ => x.getClass
	}

view raw ScalaReflects.scala hosted with ❤ by GitHub

이 변환 메소드를 써야 제대로 실행됩니다.

마지막으로, 아예 생성자의 수형까지 지정해서 생성자를 찾을 수 있도록 하면 다음과 같습니다.

	def newInstanceWithTypes[T: ClassTag](initArgs: Any*)(initArgsTypes: Class[_]*): T = {
	if (initArgs == null || initArgs.length == 0)
	return newInstance[T]()
	val parameterTypes =
	if (initArgsTypes != null) initArgsTypes.toArray
	else initArgs.map(asJavaClass(_)).toArray
	val constructor = classTag[T].runtimeClass.getConstructor(parameterTypes: _*)
	constructor.newInstance(initArgs.map(_.asInstanceOf[AnyRef]): _*).asInstanceOf[T]
	}

view raw ScalaReflects.scala hosted with ❤ by GitHub

자 이제 구현한 메소드를 이용하여 실제 테스트 코드를 제작하면 다음과 같습니다.

	class MyClass(var id: Int, var name: String) {
	def this() {
	this(0, "Unknown")
	}
	}

view raw ScalaReflectsTest.scala hosted with ❤ by GitHub

	@Test
	def instancingByDefaultContructor() {
	val instance = ScalaReflects.newInstance[MyClass]()
	Assert.assertNotNull(instance)
	Assert.assertTrue(instance.isInstanceOf[MyClass])
	}
	@Test
	def instancingByParameterizedContructor() {
	val instance = ScalaReflects.newInstance[MyClass](100, "Dynamic")
	Assert.assertNotNull(instance)
	Assert.assertTrue(instance.isInstanceOf[MyClass])
	}
	@Test
	def instancingByParameterizedContructorWithTypes() {
	val instance = ScalaReflects.newInstanceWithTypes[MyClass](100, "Dynamic")(classOf[Int], classOf[String])
	Assert.assertNotNull(instance)
	Assert.assertTrue(instance.isInstanceOf[MyClass])
	}

view raw ScalaReflectsTest.scala hosted with ❤ by GitHub

Scala가 Generic 에서는 Java 보다 .NET에 유사하여 이해하기도 쉽고, 더 쉽게 적용이 가능하다고 생각되네요.

위에서 사용한 ClassTag[T] 의 단점은 Nested Class 에 대해서는 지원하지 않습니다. 내부 Class 도 지원하려면 TypeTag[T]  로 해야 합니다.

Scala 로 java enum 구현하기

Scala 에는 특별히 enum 수형이 따로 정의되어 있지 않습니다. 그래서 java enum 과 유사하게 구현할 수 없습니다.
그래서 Scala 에서는 Enumeration 을 상속받은 Object 로 표현하면 됩니다. 다음 코드는 요일을 나타내는 DayOfWeek 값을 표현합니다.

	package kr.kth.timeperiod
	import org.joda.time.DateTimeConstants
	/**
	* 한 주의 요일을 표현합니다.
	* User: sunghyouk.bae@gmail.com
	* Date: 13. 1. 13.
	*/
	object ScalaDayOfWeek extends Enumeration {
	type ScalaDayOfWeek = Value
	// NOTE: withName, apply 메소드를 사용하세요
	val Monday = Value(DateTimeConstants.MONDAY, "Monday")
	val Tuesday = Value(DateTimeConstants.TUESDAY, "Tuesday")
	val Wednesday = Value(DateTimeConstants.WEDNESDAY, "Wednesday")
	val Thursday = Value(DateTimeConstants.THURSDAY, "Thursday")
	val Friday = Value(DateTimeConstants.FRIDAY, "Friday")
	val Saturday = Value(DateTimeConstants.SATURDAY, "Saturday")
	val Sunday = Value(DateTimeConstants.SUNDAY, "Sunday")
	}

view raw ScalaDayOfWeek.scala hosted with ❤ by GitHub

실제 사용은 java enum 과 유사합니다만 꼭 import ScalaDayOfWeek._ 를 해줘야 합니다.
그리고 java 의 valueOf(String value) 는 withName(value:String) 을 사용하면 됩니다.

	package kr.kth.timeperiod
	import kr.kth.commons.slf4j.Logging
	import org.junit.{Assert, Test}
	import org.joda.time.DateTimeConstants
	/**
	* kr.kth.timeperiod.ScalaDayOfWeekTest
	* User: sunghyouk.bae@gmail.com
	* Date: 13. 1. 13.
	*/
	class ScalaDayOfWeekTest extends Logging {
	@Test
	def dayOfWeekEquals() {
	val sunday = ScalaDayOfWeek.Sunday
	val parsed = ScalaDayOfWeek.withName("Sunday")
	Assert.assertEquals(sunday, parsed)
	Assert.assertEquals("Sunday", sunday.toString)
	Assert.assertNotEquals(ScalaDayOfWeek.Friday,ScalaDayOfWeek.Monday)
	Assert.assertEquals(ScalaDayOfWeek.Monday, ScalaDayOfWeek(DateTimeConstants.MONDAY))
	log.debug(ScalaDayOfWeek.values)
	}
	}

view raw ScalaDayOfWeekTest.scala hosted with ❤ by GitHub

Scala 언어로 Java 라이브러리 사용이라던가, 변환은 대부분은 다 됩니다. 표현력이 더 좋으니까요^^
다만 Java 에서 Scala 로 된 라이브러리를 사용하려면, 안되는 것이 많습니다.
제가 고민 중인 부분이기도 합니다.

뭐 경험이 쌓이면 방법이 생기겠죠^^

특정 코드를 병렬로 수행하기 - Java

Scala 는 scala.collection.parallel._ 에 ParArray 등 병렬 처리를 지원하는 자료구조가 지원됩니다만, Java 7 까지는 직접적으로 지원하지는 않습니다.

그래서 Java 로 유사하게 Data 처리를 병렬로 수행할 수 있도록 하는 코드를 구현해 봤습니다.

private static int getPartitionSize(int itemCount, int partitionCount) {
    return (itemCount / partitionCount) + ((itemCount % partitionCount) > 0 ? 1 : 0);
}

	public static <T, V> List<V> run(final Iterable<T> elements, final Function1<T, V> function) {
	shouldNotBeNull(elements, "elements");
	shouldNotBeNull(function, "function");
	ExecutorService executor = Executors.newFixedThreadPool(getProcessCount());
	if (log.isDebugEnabled())
	log.debug("작업을 병렬로 수행합니다. 작업 스레드 수=[{}]", getProcessCount());
	try {
	List<T> elemList = Lists.newArrayList(elements);
	int partitionSize = getPartitionSize(elemList.size(), getProcessCount());
	List<List<T>> partitions = Lists.partition(elemList, partitionSize);
	final Map<Integer, List<V>> localResults = Maps.newLinkedHashMap();
	List<Callable<List<V>>> tasks = Lists.newLinkedList(); // False Sharing을 방지하기 위해
	for (int p = 0; p < partitions.size(); p++) {
	final List<T> partition = partitions.get(p);
	final List<V> localResult = Lists.newArrayListWithCapacity(partition.size());
	localResults.put(p, localResult);
	Callable<List<V>> task = new Callable<List<V>>() {
	@Override
	public List<V> call() throws Exception {
	for (final T element : partition)
	localResult.add(function.execute(element));
	return localResult;
	}
	};
	tasks.add(task);
	}
	executor.invokeAll(tasks);
	List<V> results = Lists.newArrayListWithCapacity(elemList.size());
	for (int i = 0; i < partitions.size(); i++) {
	results.addAll(localResults.get(i));
	}
	if (log.isDebugEnabled())
	log.debug("모든 작업을 병렬로 완료했습니다. partition size=[{}]", partitions.size());
	return results;
	} catch (Exception e) {
	log.error("데이터에 대한 병렬 작업 중 예외가 발생했습니다.", e);
	throw new RuntimeException(e);
	} finally {
	executor.shutdown();
	}
	}

view raw Parallels.java hosted with ❤ by GitHub

다음과 같은 절차로 수행됩니다.

1. ExecutorService 생성 - 논리적 CPU 갯수만큼의 작업스레드를 가지게 한다.
2. 입력 데이터 컬렉션인 elements 를 Process 갯수로 나눈다. (partitions)
   각 Process 별로 작업할 컬렉션을 분할합니다. ( Process 가 4개이고, elements 수가 100개라면, 0~24 : 0 CPU, 25~49 : 1 CPU ... )
3. partition 별로 작업을 정의한다. 
4. 모든 작업을 ExecutorService에게 실행시킨다.
5. 작업 결과를 취합하여 반환한다.

위의 코드가 아주 제한적인 기능이지만, 입력값 별로 특정 로직을 수행할 때에는 유용합니다. 기본적으로 CPU가 4개라면, 최대 4배까지 빨라집니다. 물론 부가 작업이 있으니 약간은 떨어지겠지요.

만약 집계 기능의 경우는 위의 3, 4 번에서 소계를 수행하는 코드와 마지막 집계하는 코드가 더 필요할 것입니다.

테스트 코드는 다음과 같습니다. 십만번 호출 작업을 하는 테스트 코드 블럭을 100번 반복할 때, CPU 갯수 만큼 나눠서 수행하도록 합니다.

	@Slf4j
	public class ParallelsTest {
	private static final int LowerBound = 0;
	private static final int UpperBound = 99999;
	@Test
	public void parallelRunAction() {
	final Action1<Integer> action1 =
	new Action1<Integer>() {
	@Override
	public void perform(Integer x) {
	for (int i = LowerBound; i < UpperBound; i++) {
	Hero.findRoot(i);
	}
	if (log.isDebugEnabled())
	log.debug("FindRoot({}) returns [{}]", UpperBound, Hero.findRoot(UpperBound));
	}
	};
	@Cleanup
	AutoStopwatch stopwatch = new AutoStopwatch();
	Parallels.run(Range.range(0, 100), action1);
	}
	@Test
	public void parallelRunFunction() {
	final Function1<Integer, Double> function1 =
	new Function1<Integer, Double>() {
	@Override
	public Double execute(Integer x) {
	for (int i = LowerBound; i < UpperBound; i++) {
	Hero.findRoot(i);
	}
	if (log.isDebugEnabled())
	log.debug("FindRoot({}) returns [{}]", UpperBound, Hero.findRoot(UpperBound));
	return Hero.findRoot(UpperBound);
	}
	};
	@Cleanup
	AutoStopwatch stopwatch = new AutoStopwatch();
	List<Double> results = Parallels.run(Range.range(0, 100), function1);
	Assert.assertNotNull(results);
	Assert.assertEquals(100, results.size());
	}
	public static class Hero {
	private static final double Tolerance = 1.0e-10;
	public static double findRoot(double number) {
	double guess = 1.0;
	double error = Math.abs(guess * guess - number);
	while (error > Tolerance) {
	guess = (number / guess + guess) / 2.0;
	error = Math.abs(guess * guess - number);
	}
	return guess;
	}
	}
	}

view raw ParallelsTest.java hosted with ❤ by GitHub

* 소스 중에 컬렉션 관련 메소드는 Google Guava 13.0 을 사용했습니다.

Scala 병렬 프로그래밍

Scala 가 기본적으로 병렬처리를 지원해서 만들어봤습니다.

scala.collection.parallel._ 에 보시면 여러가지 병렬 프로그래밍을 지원하는 자료구조들이 있습니다. 

물론 java 의 ExecutorService를 이용하여 처리할 수 있습니다만, 우아하게 코딩량을 줄여서 처리할 수 있어서 좋습니다.

먼저, void 형 메소드인 ( => Unit) 형태의 메소드 블럭을 주어진 횟수만큼 병렬로 호출하는 코드를  보면, 아주 간단히 ParArray 를 생성하고, map 메소드를 호출하여 지정된 메소드를 수행하도록 합니다.

	def runUnitAsParallel(count: Int)(block: => Unit) {
	log.debug("멀티스레드 환경에서 메소드들을 [{}] 번 실행합니다.", count)
	try {
	val latch = new CountDownLatch(count)
	val pc = collection.parallel.mutable.ParArray.iterate(0, count)(x => x)
	pc.tasksupport = new ThreadPoolTaskSupport()
	pc map {
	_ => {
	block
	latch.countDown()
	}
	}
	latch.await()
	} catch {
	case e: InterruptedException => log.warn("작업 중 interrupted 되었습니다.")
	case e: Exception => log.error("작업 중에 예외가 발생했습니다.", e)
	}
	log.debug("멀티스레드 환경에서 메소드들을 [{}] 번 실행했습니다.", count)
	}

view raw ParallelTestTool.scala hosted with ❤ by GitHub

핵심 코드는 상당히 간단하죠?
그럼 Java 로 비슷한 기능을 만든다면?

	private static ExecutorService newExecutorService() {
	return Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
	}
	public static void runTasks(int count, final Runnable runnable) {
	ExecutorService executor = newExecutorService();
	try {
	final CountDownLatch latch = new CountDownLatch(count);
	for (int i = 0; i < count; i++) {
	executor.submit(new Runnable() {
	@Override
	public void run() {
	runnable.run();
	latch.countDown();
	}
	});
	}
	latch.await();
	} catch (InterruptedException e) {
	if (log.isErrorEnabled())
	log.error("작업 수행 중 예외가 발생했습니다.", e);
	throw new RuntimeException(e);
	} finally {
	executor.shutdown();
	}
	}

view raw TestTool.java hosted with ❤ by GitHub

차이점이라면 ExecutorService 를 직접 사용하느냐, 내부코드에서 해주느냐의 차이입니다만, scala 의 경우 collection에 filtering, streaming 등 상당히 많은 반복 작업들을 이미 구현해 놓아서, 쓰기도 쉽고, 코드도 간단명료해지네요^^

scala 로 만든 병렬 실행 테스트 코드를 보면,

	private final val LowerBound: Int = 0
	private final val UpperBound: Int = 100000
	@Test
	def runUnitAsParallelTest {
	def runnable = {
	(LowerBound to UpperBound).foreach {
	i => Hero.findRoot(i)
	}
	log.debug("Unit: FindRoot({}) returns [{}]", UpperBound, Hero.findRoot(UpperBound))
	Hero.findRoot(UpperBound)
	}
	val stopwatch: AutoStopwatch = new AutoStopwatch()
	ParallelTestTool.runUnitAsParallel(100) { runnable; runnable }
	stopwatch.close()
	}

view raw ScalaTestToolTest.scala hosted with ❤ by GitHub

함수 호출이 아니라 코드 블럭을 정의한 것 같지요?
함수형 언어의 currying 을 이용하여, code block 을 아예 넘길 수 있는 것도 아주 좋은 장점이 되겠습니다.

요즘 Scala의 매력에 푹 빠져있는데, 시간이 나면 Scala 로 Hibernate 와 연계한 base class library 를 만들어야 겠습니다. (case class 를 보면 얼마나 생산성이 좋은지 알 수 있습니다)

Scala for C# Programmer

C# 개발자가 Scala 를 쉽게 배울 수 있도록 아주 잘 설명된 블로그가 있어서 소개합니다.

Scala 공식 사이트의  Learn Scala 페이지 중에 있었네요.

If you are a C# programmer, you may find the series "Scala for C# programmers" by Ivan Towlson on flatlander quite helpful:

• Part 1 Mixins and Traits

• Part 1a Mixins and Traits, Behind the scenes

• Part 2 Singletons

• Part 3 Pass by Name

• Part 4 Multiple return values

• Part 5 Implicits

• Part 6 Infix Operators

보시다 시피 C#의 Lambda Expression ,  Extension Methods 등을 알고 있다면, JVM 고유의 특징을 제외하고는 위의 내용을 이해하면 가장 쉽게 Scala 를 배울 수 있겠네요^^

한가지 빠졌다면, case class 에 의한 match 와 @BeanProperty 에 대한 내용은 따로 배워야 할 듯... Field 변수에 대한 getter / setter 는 C# 이 가장 좋은 듯

또 한가지 C#의 메소드 overloading 과 Scala 의 overloading 은 메커니즘이 아주 틀립니다. Scala는 수형검사를 엄밀히 하지 않네요. 이 부분은 API 제작 시 C# 이 더 유리합니다.
다만 사용하는 입장에서는 둘 다 Named Parameter를 지원하므로, 사용하는 방법은 유사합니다.

아, Scala 는 함수형 언어의 특징인 Currying 를 이용하여 여러가지 Signature를 만들 수 있습니다. 이 방식이 더 유연한 방식이라 볼 수 있겠네요.

Scala 용 Slf4j Logging

Scala에서 직접 Slf4j 를 사용해도 가능하지만,  좀 더 편하게 사용할 수 기존 Logger를 Scala 용으로 Wrapping 하였습니다.

	package kr.kth.commons.slf4j
	import org.slf4j.{Logger => Slf4jLogger, Marker}
	import annotation.varargs
	/**
	* Scala를 위한 Logger 입니다.
	* User: sunghyouk.bae@gmail.com
	* Date: 13. 1. 6.
	*/
	class Logger(val log: Slf4jLogger) {
	import scala.language.implicitConversions
	private implicit def _any2String(msg: Any): String =
	msg match {
	case null => "<null>"
	case _ => msg.toString
	}
	lazy val name = log.getName
	lazy val isTraceEnabled = log.isTraceEnabled
	@inline final def isTraceEnabled(marker: Marker) = log.isTraceEnabled(marker)
	@inline final def trace(msg: String, t: Throwable) {
	if (isTraceEnabled)
	log.trace(msg, t)
	}
	@inline final def trace(marker: Marker, msg: String, t: Throwable) {
	if (isTraceEnabled(marker))
	log.trace(marker, msg, t)
	}
	@inline
	@varargs final def trace(format: Any, arguments: Any*) {
	if (isTraceEnabled)
	log.trace(format.toString, arguments.map(_.asInstanceOf[AnyRef]): _*)
	}
	@inline
	@varargs final def trace(marker: Marker, format: Any, arguments: Any*) {
	if (isTraceEnabled(marker))
	log.trace(marker, format.toString, arguments.map(_.asInstanceOf[AnyRef]): _*)
	}
	lazy val isDebugEnabled = log.isDebugEnabled
	@inline final def isDebugEnabled(marker: Marker) = log.isDebugEnabled(marker)
	@inline final def debug(msg: String, t: Throwable) {
	if (isDebugEnabled)
	log.debug(msg, t)
	}
	@inline final def debug(marker: Marker, msg: String, t: Throwable) {
	if (isDebugEnabled(marker))
	log.debug(marker, msg, t)
	}
	@inline
	@varargs final def debug(format: Any, arguments: Any*) {
	if (isDebugEnabled)
	log.debug(format.toString, arguments.map(_.asInstanceOf[AnyRef]): _*)
	}
	@inline
	@varargs final def debug(marker: Marker, format: Any, arguments: Any*) {
	if (isDebugEnabled(marker))
	log.debug(marker, format.toString, arguments.map(_.asInstanceOf[AnyRef]): _*)
	}
	lazy val isInfoEnabled = log.isInfoEnabled
	@inline final def isInfoEnabled(marker: Marker) = log.isInfoEnabled(marker)
	@inline final def info(msg: String, t: Throwable) {
	if (isInfoEnabled)
	log.info(msg, t)
	}
	@inline final def info(marker: Marker, msg: String, t: Throwable) {
	if (isInfoEnabled(marker))
	log.info(marker, msg, t)
	}
	@inline
	@varargs final def info(format: Any, arguments: Any*) {
	if (isInfoEnabled)
	log.info(format.toString, arguments.map(_.asInstanceOf[AnyRef]): _*)
	}
	@inline
	@varargs final def info(marker: Marker, format: Any, arguments: Any*) {
	if (isInfoEnabled(marker))
	log.info(marker, format.toString, arguments.map(_.asInstanceOf[AnyRef]): _*)
	}
	lazy val isWarnEnabled = log.isWarnEnabled
	@inline final def isWarnEnabled(marker: Marker) = log.isWarnEnabled(marker)
	@inline final def warn(msg: String, t: Throwable) {
	if (isWarnEnabled)
	log.warn(msg, t)
	}
	@inline final def warn(marker: Marker, msg: String, t: Throwable) {
	if (isWarnEnabled(marker))
	log.warn(marker, msg, t)
	}
	@inline
	@varargs final def warn(format: Any, arguments: Any*) {
	if (isWarnEnabled)
	log.warn(format.toString, arguments.map(_.asInstanceOf[AnyRef]): _*)
	}
	@inline
	@varargs final def warn(marker: Marker, format: Any, arguments: Any*) {
	if (isWarnEnabled(marker))
	log.warn(marker, format.toString, arguments.map(_.asInstanceOf[AnyRef]): _*)
	}
	lazy val isErrorEnabled = log.isErrorEnabled
	@inline final def isErrorEnabled(marker: Marker) = log.isErrorEnabled(marker)
	@inline final def error(msg: String, t: Throwable) {
	if (isErrorEnabled)
	log.error(msg, t)
	}
	@inline final def error(marker: Marker, msg: String, t: Throwable) {
	if (isErrorEnabled(marker))
	log.error(marker, msg, t)
	}
	@inline
	@varargs final def error(format: Any, arguments: Any*) {
	if (isErrorEnabled)
	log.error(format.toString, arguments.map(_.asInstanceOf[AnyRef]): _*)
	}
	@inline
	@varargs final def error(marker: Marker, format: Any, arguments: Any*) {
	if (isErrorEnabled(marker))
	log.error(marker, format.toString, arguments.map(_.asInstanceOf[AnyRef]): _*)
	}
	}
	object Logger {
	import scala.reflect.{classTag, ClassTag}
	lazy val RootLoggerName = Slf4jLogger.ROOT_LOGGER_NAME
	/**
	* 지정된 이름을 Logger 이름으로 사용합니다. 예: Logger("LoggerName")
	*/
	def apply(name: String): Logger = new Logger(org.slf4j.LoggerFactory.getLogger(name))
	/**
	* 지정한 클래스 수형에 맞는 Logger를 반환합니다. 예: Logger(this.type)
	*/
	def apply(cls: Class[_]): Logger = apply(cls.getName)
	/**
	* 특정 클래스에 맞는 Logger 를 반환합니다. 예: Logger[classOf[MyClass]]
	*/
	def apply[C: ClassTag](): Logger = apply(classTag[C].runtimeClass.getName)
	/**
	* Root Logger
	*/
	def rootLogger = apply(RootLoggerName)
	}

view raw Logger.scala hosted with ❤ by GitHub

Scala 의 Mixin 방식으로 사용하기 위해서 Logging trait 을 구현했습니다.

	package kr.kth.commons.slf4j
	import org.slf4j.Marker
	import annotation.varargs
	/**
	* 로그를 사용할 클래스에서 MixIn 방식으로 상속해서 사용하면 됩니다. ( class A extends Logger ... )
	* User: sunghyouk.bae@gmail.com
	* Date: 13. 1. 6.
	*/
	trait Logging {
	protected lazy val log: Logger = Logger(getClass)
	protected def loggerName = log.name
	protected lazy val isTranceEnabled = log.isTraceEnabled
	protected def trace(msg: String, t: Throwable) {
	log.trace(msg, t)
	}
	protected def trace(marker: Marker, msg: String, t: Throwable) {
	log.trace(marker, msg, t)
	}
	@varargs
	protected def trace(format: Any, arguments: Any*) {
	log.trace(format, arguments)
	}
	@varargs
	protected def trace(marker: Marker, format: Any, arguments: Any*) {
	log.trace(marker, format, arguments)
	}
	protected lazy val isDebugEnabled = log.isDebugEnabled
	protected def debug(msg: String, t: Throwable) {
	log.debug(msg, t)
	}
	protected def debug(marker: Marker, msg: String, t: Throwable) {
	log.debug(marker, msg, t)
	}
	@varargs
	protected def debug(format: Any, arguments: Any*) {
	log.debug(format, arguments)
	}
	@varargs
	protected def debug(marker: Marker, format: Any, arguments: Any*) {
	log.debug(marker, format, arguments)
	}
	protected lazy val isInfoEnabled = log.isInfoEnabled
	protected def info(msg: String, t: Throwable) {
	log.info(msg, t)
	}
	protected def info(marker: Marker, msg: String, t: Throwable) {
	log.info(marker, msg, t)
	}
	@varargs
	protected def info(format: Any, arguments: Any*) {
	log.info(format, arguments)
	}
	@varargs
	protected def info(marker: Marker, format: Any, arguments: Any*) {
	log.info(marker, format, arguments)
	}
	protected lazy val isWarnEnabled = log.isWarnEnabled
	protected def warn(msg: String, t: Throwable) {
	log.warn(msg, t)
	}
	protected def warn(marker: Marker, msg: String, t: Throwable) {
	log.warn(marker, msg, t)
	}
	@varargs
	protected def warn(format: Any, arguments: Any*) {
	log.warn(format, arguments)
	}
	@varargs
	protected def warn(marker: Marker, format: Any, arguments: Any*) {
	log.warn(marker, format, arguments)
	}
	protected lazy val isErrorEnabled = log.isErrorEnabled
	protected def error(msg: String, t: Throwable) {
	log.error(msg, t)
	}
	protected def error(marker: Marker, msg: String, t: Throwable) {
	log.error(marker, msg, t)
	}
	@varargs
	protected def error(format: Any, arguments: Any*) {
	log.error(format, arguments)
	}
	@varargs
	protected def error(marker: Marker, format: Any, arguments: Any*) {
	log.error(marker, format, arguments)
	}
	}

view raw Logging.scala hosted with ❤ by GitHub

Logging trait 을 사용하여 MixIn 방식으로 사용하는 예입니다.

	package kr.kth.commons.slf4j
	import org.junit.Test
	/**
	* User: sunghyouk.bae@gmail.com
	* Date: 13. 1. 8
	*/
	class LoggingTest extends Logging {
	@Test
	def printString() {
	log.trace("Trace Simple String")
	log.debug("Debug Simple String")
	log.info("Info Simple String")
	log.warn("Warn Simple String")
	log.error("Error Simple String")
	}
	@Test
	def printAnyVal() {
	log.debug("print 1")
	log.debug(1)
	}
	case class Card(val name: String, val year: Int)
	@Test
	def printAnyRef() {
	log.debug("print Card object (name=Credit, year=2006)")
	log.debug(new Card("Credit", 2006))
	}
	@Test
	def printFormatString() {
	log.trace("Format String. Card=[{}]", new Card("Format", 2013))
	log.debug("Format String. Card=[{}]", new Card("Format", 2013))
	log.info("Format String. Card=[{}]", new Card("Format", 2013))
	log.warn("Format String. Card=[{}]", new Card("Format", 2013))
	log.error("Format String. Card=[{}]", new Card("Format", 2013))
	}
	@Test
	def printException() {
	log.debug("Print exception", new RuntimeException("for test"))
	}
	}

view raw LoggingTest.scala hosted with ❤ by GitHub

Scala 와 Java 의 가변인자(varargs)를 가진 메소드를 상호 호출하는 방법

Java 에서 가변인자 형식을 사용하는 방식은 다음과 같습니다.

void javaPrint(String: format, Object... args)

Scala 에서는 다음과 같이 표현합니다. 물론 AnyRef* 보다 Any* 를 사용하면 primitive type 들도 가능합니다.

def scalaPrint(format:String, @varargs args: Any*)


먼저 Java에서 Scala 로 만들어진 scalaPrint() 를 가변인자 형식으로 호출하게하기 위해 @varargs를 지정하게 하면 됩니다.

그럼 Scala 언어에서 Java 로 만든 javaPrint 를 호출하려면 다음과 같이 해야 합니다.

@varargs
def wrappingJavaPrint(format:String, args: Any*) {
    javaPrint(format, args.map( _.asInstanceOf[AnyRef]) : _* )
}

로 호출하면 java 의 가변형식을 호출합니다.
"_*" 를 붙이는 이유는 Scala compiler 에게 가변인자로 호출함을 명시적으로 알려주게 됩니다.

 Scala 2.8에서는 이런 문제가 좀 많았는데, 그 후로는 이런 방식으로 정착된 것 같습니다.
전 위의 방법을 몰라서, 좀 헤맸습니다^^

Scala Community Projects from Scala Official Site

Scala Community Project 정보입니다.
Scala 를 사용할 때, Java 라이브러리를 사용하는 것도 가능하지만,  Only Scala 로 개발하고 싶은 개발자에게는 필요한 정보입니다.

from http://www.scala-lang.org/node/27499

Community Projects

Special thanks to the 43 projects that have made releases available for this version of Scala!

• ScalaLogging
  Convenient and performant logging in Scala
  Location: "com.typesafe" %% "scalalogging-slf4j" % "1.0.0"
   
• specs2
  specs2 is a library for writing software specifications in Scala
  Location: "org.specs2" %% "specs2" % "1.13"
   
• ScalikeJDBC
  A tidy SQL-based DB access library for Scala.
  Location: "com.github.seratch" %% "scalikejdbc" % "1.4.1"
   
• scopt
  scopt is a little command line options parsing library.
  Location: "com.github.scopt" %% "scopt" % "2.1.0"
   
• ScalaMock 3
  Native Scala Mocking with added macro-goodness
  Location:
  For ScalaTest integration: "org.scalamock" %% "scalamock-scalatest-support" % "3.0"
  For Specs2 integration: "org.scalamock" %% "scalamock-specs2-support" % "3.0"
   
• nscala-time
  A new Scala wrapper for Joda Time based on scala-time.
  Location: "com.github.nscala-time" %% "nscala-time" % "0.2.0"
   
• Slick
  Scala Language-Integrated Connection Kit
  Location: "com.typesafe" %% "slick" % "1.0.0-RC1"
   
• sfreechart
  SFreeChart is a Scala-friendly wrapper for JFreeChart
  Location: "com.github.wookietreiber.sfreechart" %% "sfreechart" % "0.1.0"
   
• ScalaAudioFile
  A library to read and write uncompressed audio files (AIFF, WAVE, etc.)
  Location: "de.sciss" %% "scalaaudiofile" % "1.2.+"
   
• ScalaOSC
  A library for OpenSoundControl (OSC), a message protocol used in multi-media applications.
  Location: "de.sciss" %% "scalaosc" % "1.1.+"
   
• ScalaCollider
  A sound synthesis library for the SuperCollider server
  Location: "de.sciss" %% "scalacollider" % "1.3.+"
   
• ScalaInterpreterPane
  A Swing based front-end for the Scala REPL (interpreter)
  Location: "de.sciss" %% "scalainterpreterpane" % "1.3.+"
   
• redisclient
  Scala driver for Redis
  Location: "net.debasishg" %% "redisclient" % "2.9"
   
• ScalaSTM
  Software transactional memory for Scala, plus STM-friendly concurrent sets and maps
  Location: "org.scala-stm" %% "scala-stm" % "0.7"
   
• ScalaJPA
  Scala wrappers for JPA 1.0 Persistence Framework
  Location: "org.scala-libs" %% "scalajpa" % "1.4"
   
• ScalaTest
  Simple, clear tests and executable specifications
  Location: "org.scalatest" % "scalatest_2.10" % "1.9.1" // For ScalaTest 1.9.1, or
  "org.scalatest" % "scalatest_2.10" % "2.0.M5b" // For ScalaTest 2.0.M5
   
• AudioWidgets
  Specialized Swing widgets for audio applications in Scala
  Location: "de.sciss" %% "audiowidgets" % "1.1.+"
  core: "de.sciss" %% "audiowidgets-core" % "1.1.+"
  scala-swing bindings: "de.sciss" %% "audiowidgets-swing" % "1.1.+"
   
• ScalaColliderSwing
  A Swing and REPL front-end for ScalaCollider
  Location: "de.sciss" %% "scalacolliderswing" % "1.3.+"
   
• Strugatzki
  Algorithms for extracting audio features and matching audio file similarities
  Location: "de.sciss" %% "strugatzki" % "1.3.+"
   
• ScissDSP
  Collection of DSP algorithms and components for Scala
  Location: "de.sciss" %% "scissdsp" % "1.1.+"
   
• FScapeJobs
  A library to launch digital signal processing jobs for FScape via OSC
  Location: "de.sciss" %% "fscapejobs" % "1.2.+"
   
• FingerTree
  A Scala implementation of the versatile purely functional data structure of the same name.
  Location: "de.sciss" %% "fingertree" % "1.2.+"
   
• scalaz
  Type Classes and Pure Functional Data Structures for Scala
  Location: "org.scalaz" %% "scalaz-core" % "7.0.0-M7"
   
• scallop
  a simple (yet powerful) command-line arguments parsing library for Scala.
  Location: "org.rogach" %% "scallop" % "0.6.3"
   
• Basis
  An experimental foundation library focussed on efficiency and clean design.
  Location: "it.reify" %% "basis" % "0.0"
  "it.reify" %% "basis-collections" % "0.0"
  "it.reify" %% "basis-containers" % "0.0"
  "it.reify" %% "basis-control" % "0.0"
  "it.reify" %% "basis-generators" % "0.0"
  "it.reify" %% "basis-math" % "0.0"
  "it.reify" %% "basis-memory" % "0.0"
  "it.reify" %% "basis-runtime" % "0.0"
  "it.reify" %% "basis-sequential" % "0.0"
  "it.reify" %% "basis-text" % "0.0"
  "it.reify" %% "basis-util" % "0.0"
   
• scala-poi
  A convenient API for creating Excel spreadsheets using Apache POI.
  Location: "info.folone" %% "poi-scala" % "0.7"
   
• shapeless
  An exploration of generic/polytypic programming in Scala
  Location: "com.chuusai" %% "shapeless" % "1.2.3"
   
• sqltyped
  a macro which infers Scala types from database
  Location: "fi.reaktor" %% "sqltyped" % "0.1.0"
   
• Jackson Scala Module
  Scala data type support for the Jackson JSON processing library
  Location: "com.fasterxml.jackson.module" %% "jackson-module-scala" % "2.1.3"
   
• Metrics-scala
  Capturing JVM- and application-level metrics. So you know what's going on.
  Location: "nl.grons" % "metrics-scala_2.10" % "2.2.0"
   
• LucreSTM
  Extension of Scala-STM, adding optional durability layer, and providing API for confluent and reactive event layers
  Location: "de.sciss" %% "lucrestm" % "1.6.+"
  core: "de.sciss" %% "lucrestm-core" % "1.6.+"
  BerkeleyDB JE bindings: "de.sciss" %% "lucrestm-bdb" % "1.6.+"
  Resolvers needed for lucrestm-bdb: "Oracle Repository" at "http://download.oracle.com/maven"
   
• LucreData
  Transactional data structures (skip list, skip octree, total order) for Scala
  Location: "de.sciss" %% "lucredata" % "1.6.+"
  core: "de.sciss" %% "lucredata-core" % "1.6.+"
  gui-views: "de.sciss" %% "lucredata-views" % "1.6.+"
   
• LucreEvent
  Reactive event-system for LucreSTM
  Location: "de.sciss" %% "lucreevent" % "1.6.+"
  core: "de.sciss" %% "lucreevent-core" % "1.6.+"
  expression trees: "de.sciss" %% "lucreevent-expr" % "1.6.+"
   
• LucreConfluent
  Confluently persistent references for Scala
  Location: "de.sciss" %% "lucreconfluent" % "1.6.+"
  core: "de.sciss" %% "lucreconfluent-core" % "1.6.+"
  events: "de.sciss" %% "lucreconfluent-event" % "1.6.+"
   
• SoundProcesses
  A framework for creating and managing ScalaCollider based sound processes
  Location: "de.sciss" %% "soundprocesses" % "1.3.+"
  Resolvers needed for dependencies: "Oracle Repository" at "http://download.oracle.com/maven"
   
• Graph for Scala
  In-memory graph library seamlessly fitting into the Scala Collection Library
  Location: "com.assembla.scala-incubator" % "graph-core_2.10" % "1.6.0"
   
• Kiama
  Kiama is a Scala library for language processing
  Location: "com.googlecode.kiama" % "kiama_2.10" % "1.4.0"
   
• Scala Migrations
  Database migrations for Derby, MySQL, PostgreSQL and Oracle written in a Scala DSL
  Location: "com.imageworks.scala-migrations" %% "scala-migrations" % "1.1.1"
   
• Spire
  Powerful new number types and numeric abstractions for Scala.
  Location: "org.spire-math" % "spire_2.10.0" % "0.3.0-M7"
   
• squeryl
  A Scala ORM and DSL for talking with Databases with minimum verbosity and maximum type safety
  Location: "org.squeryl" %% "squeryl" % "0.9.5-6"
   
• Scales Xml
  Scales Xml provides superb performance with low memory usage, a unified pull and push model, Iteratee and Iterator based pull parsing, equality framework, both an embedded XPath DSL and string based XPath 1.0 support.
  Location: "org.scalesxml" %% "scales-xml" % "0.4.4"
   
• geotrellis
  Geographic data processing engine for high performance applications.
  Location: "com.azavea.geotrellis" %% "geotrellis" % "0.8.0-RC1"
   
• SORM
  A pure case-classes oriented ORM framework for Scala
  Location: "com.github.nikita-volkov" % "sorm" % "0.3.5"