Question

First of all, I know how to write a basic/intermediate level
makefile. In my c++ projects I use a makefile that does a lot of stuff
automatically. The most important to me is that it automatically
detects all source files (which are always in the same folder) using
wildcards, uses that to predict the name (and location) of all object files, and compiles appropriately.

Recently I’ve been trying to achieve the same effect with my scala
projects, but I’ve hit two obstacles.

• Copilled class files which belong to packages are stored inside
  subdirectories (like com/me/mypack/). This is a problem because
  Make needs to find these files to check the timestamps (and I
  have no idea how to do that automatically).
• Some source files (such as those defining a package object)
  generate class files with different naming standards. Again, Make
  needs to know where these class files are and I don’t know how to
  do that automatically.

The consequence of this is that the “problematic” source files are
recompiled every time I run make (which is aggravated by scala’s long
compile times). I’d like to know how to fix that without having to
manually write out the entire list of expected class files.

EDIT As an extra note: I’d like to avoid placing the source files in subdirectories. I like keeping them all in the same directory for several reasons.

Answer 1

You should use sbt or Maven for Scala. These are designed specifically for the way Scala and Java work, and they will be much easier to set up and use. They also provide many more features than make does.

These tools are used for a variety of things. Compiling is a big one, but they are also important for dependency management. Also, sbt (and probably Maven?) does “incremental compilation”, so that only classes that have changed are recompiled, which speeds up compilation.

I personally use sbt, but I know people who prefer Maven.