Solving these puzzles (and comparing your solutions with solutions of others) is a good way to “get a feel” for programing language and to explore idiomatic approaches to particular kind of problems.

Today we can easily find solutions to the problems in almost any wide-spread programming language. However most of the attempts use a single programing language and provide only one solution to each problem.

By providing multiple types of solutions we can enrich our programming “toolbox” and learn pros and cons of various methods. By using several programming languages simultaneously we can easily correlate different programming paradigms and explore limits of language expressive power.

Here goes my take on Ninety-Nine Problems in:

• Scala,
• Java,
• Clojure,
• Haskell.

All the code is available as a GitHub repository.

See also: Scala for Project Euler.

Working with lists

[1 2 3 7 5] -> 5

[1 2 3 7 5] -> 7

[1 2 3 7 5] 4 -> 7

[1 2 3 5 7] -> 5

[1 2 3 7 5] -> [5 7 3 2 1]

[1 2 3 3 2 1] -> true

[1 [2 3 [5 7] 3] 1] -> [1 2 3 5 7 3 1]

[1 1 1 2 2 3 1 5 5 3 3] -> [1 2 3 1 5 3]

[1 1 1 2 2 3 1 5 5 3 3] -> [[1 1 1] [2 2] [3] [1] [5 5] [3 3]]

[1 1 1 2 2 3 1 5 5 3 3] -> [(3 1) (2 2) (1 3) (1 1) (2 5) (2 3)]

[1 1 1 2 2 3 1 5 5 3 3] -> [(3 1) (2 2) 3 1 (2 5) (2 3)]

[(3 1) (2 2) 3 1 (2 5) (2 3)] -> [1 1 1 2 2 3 1 5 5 3 3]

[1 1 1 2 2 3 1 5 5 3 3] -> [(3 1) (2 2) 3 1 (2 5) (2 3)]

[1 2 3 1] -> [1 1 2 2 3 3 1 1]

[1 2 3 1] 3 -> [1 1 1 2 2 2 3 3 3 1 1 1]

[1 2 3 4 5 6 7 8] 3 -> [1 2 4 5 7 8]

[1 2 3 4 5 6 7 8] 3 -> ([1 2 3] [4 5 6 7 8])

[1 2 3 4 5 6 7 8] 3 7 -> [3 4 5 6 7]

[1 2 3 4 5 6 7 8] 3 -> [3 4 5 6 7 8 1 2 3]

[1 2 3 4] 2 -> (2, [1 3 4])

[1 2 3 4] 2 5 -> [1 5 2 3 4]

4 9 -> [1 2 3 4 5 6 7 8 9]

[1 2 3 4 5 6 7 8] 3 -> [7 3 5]

To be continued…

The project is purely educational. It is a product of a long vacation in the country and a desire to learn how all this stuff really works.

I learned a lot from the project and hope it might be useful to the people who want to know more about lexers, parsers, AST, Java bytecode and other similar fun, but tricky things.

Feature list, screenshots, binaries and the source code are available on the project page.

An initial projector malfunction made me a little bit nervous about speaking without my thoroughly prepared slides, however, everything was resolved and my presentation seemed to went fine.

In addition to project presentations we had two days for hacking Scala code. It was a pleasure to see so many projects and so much involvement. These people are really passionate about what they do!

As turned out (surprise), many programmers were using IDEA with the Scala plugin as their primary development environment. Usually I encounter only “virtual” plugin users, but there I had a chance to provide a truly personal support. I was both proud of our work and ashamed of whatever bug it may have

Right before the Scalathon I had been evaluating ScalaCL compiler plugin for use in our project, so I was really glad to meet Olivier Chafik there in person. Our talk shed light on many tricky parts of ScalaCL implementation.

Being among all those people form mailing lists, tweets, blogs, forums and even books makes you feel a part of community (and Scala community is an amazing community to be part of). I would like to thank all the organizers for their great work!

Here are some photos of the Philadelphia, Scalathon, ENIAC and me.

SleepArchiver at SourceForge.net:

• Project
• Source code (GitHub mirror)
• Bug tracker
• Feature requests
• Forum

A list of features yet to be implemented:

• Translate GUI to other languages
• Create .deb software package for Ubuntu
• Create .dmg image for Mac OS X
• Implement data analysis
• Add an ability to import data from Sleeptracker bundled software
• Write good documentation
• …your most wanted feature

Everyone is welcome to contribute by becoming a developer and join the project.

Thanks to short concrete problems and number-only solutions you don’t have to thinker with IDEs, GUI designers, programming libraries and frameworks, so Project Euler is an excellent tool for learning a new programming language or improving your core programming skills.

Why use Scala

Although all general-purpose programming languages are Turing-complete and thus suitable for Project Euler, each language has its own philosophy and set of tools. In spite of programming language “holy wars”, the truth is that different tasks demand different tools.

Since Scala is a multi-paradigm programming language, it allows programmers to efficiently express a wide range of common programming patterns. Most Project Euler problems imply advanced transformation of numeric or symbolic data and Scala’s functional programming features are the perfect tool for that purpose (moreover, unlike pure functional languages, being a hybrid language, Scala provides object-oriented capabilities when modeling or simulation is required).

So, what does Scala have to offer for Project Euler? Here is the list of most valuable features:

• scripting,
• type-inference,
• first-class functions,
• tail call optimization,
• lazy evaluation,
• excellent collection library,
• sequence comprehensions.

On the top of everything else, Scala brings enjoyment to your coding. According to The Right Tool Scala is ranked high in the following categories:

• I enjoy using this language (2/50)
• I use this language out of choice (1/50)
• This language is expressive (3/50)
• I find code written in this language very elegant (2/50)

Thus Scala is the right tool for those who want to mingle the useful with the pleasant.

Sample solutions

This section contains solutions to the first 33 problems. You may use them either to size up how well Scala plays in Project Euler, or to compare your own solutions with the samples.

All the code is available as a GitHub repository.

See also: Ninety-Nine Problems in Scala, Java, Clojure and Haskell.
 

val r = (1 until 1000).view.filter(n => n % 3 == 0 || n % 5 == 0).sum

assert(r == 233168) // 7 ms

lazy val fs: Stream[Int] = 
  0 #:: 1 #:: fs.zip(fs.tail).map(p => p._1 + p._2)

val r = fs.view.takeWhile(_ <= 4000000).filter(_ % 2 == 0).sum

assert(r == 4613732) // 1 ms

lazy val ps: Stream[Int] = 2 #:: Stream.from(3).filter(i =>
  ps.takeWhile(j => j * j <= i).forall(i % _ > 0))

val n = 600851475143L

val limit = math.sqrt(n)

val r = ps.view.takeWhile(_ < limit).filter(n % _ == 0).last

assert(r == 6857) // 265 ms

val r = (100 to 999).view
        .flatMap(i => (i to 999).map(i *))
        .filter(n => n.toString == n.toString.reverse)
        .max

assert(r == 906609) // 102 ms

val r = Range(20, Int.MaxValue)
        .find(n => Range(2, 21).forall(n % _ == 0)).get

assert(r == 232792560) // 23 s

val numbers = 1 to 100

def square(n: Int) = n * n

val r = square(numbers.sum) - numbers.map(square).sum

assert(r == 25164150) // 1 ms

lazy val ps: Stream[Int] = 2 #:: Stream.from(3).filter(i =>
  ps.takeWhile(j => j * j <= i).forall(i % _ > 0))

val r = ps(10000)

assert(r == 104743) // 24 ms

val s = """<raw input data>"""

val r = s.filter(_.isDigit).map(_.asDigit).sliding(5)
        .map(_.product).max

assert(r == 40824) // 33 ms

val limit = (1 to 1000).find(n => n + math.sqrt(n) >= 1000).get

val rs = for(b <- 2 until limit; a <- 1 until b; c = 1000 - a - b
             if a * a + b * b  == c * c) yield a * b * c

val r = rs(0)

assert(r == 31875000) // 32 ms

lazy val ps: Stream[Int] = 2 #:: Stream.from(3).filter(i =>
  ps.takeWhile(j => j * j <= i).forall(i % _ > 0))

val r = ps.view.takeWhile(_ < 2000000).foldLeft(0L)(_ + _)

assert(r == 142913828922L) // 1 s

val s = """<raw input data>"""

val ns = s.split("\\s+").map(_.toInt)

def m(i: Int, p: Int, c: Int): Int =
  if(c > 0) ns(i) * m(i + p, p, c - 1) else 1

def ms(xs: Seq[Int], ys: Seq[Int], p: Int) =
  ys.flatMap(y => xs.map(x => m(20 * y + x, p, 4)))

val ps = ms(0 to 19, 0 to 15, 20) ++ ms(0 to 15, 0 to 19, 1) ++ 
         ms(0 to 15, 0 to 15, 21) ++ ms(3 to 19, 0 to 15, 19)

val r = ps.max

assert(r == 70600674) // 4 ms

lazy val ts: Stream[Int] = 
  0 #:: ts.zipWithIndex.map(p => p._1 + p._2 + 1)

def p(t: Int) = Range(1, Int.MaxValue)
                .takeWhile(n => n * n <= t)
                .foldLeft(0)((s, n) => if(t % n == 0) s + 2 else s)

val r = ts.find(p(_) > 500).get

assert(r == 76576500) // 1 s

val s = """<raw input data"""

val r = s.split("\\s+").map(_.take(11).toLong).sum.toString
        .take(10).toLong

assert(r == 5537376230L) // 2 ms

def from(n: Long, c: Int = 0): Int = if(n == 1) c + 1 else 
  from(if(n % 2 == 0) n / 2 else 3 * n + 1, c + 1)

val r = (1 until 1000000).view.map(n => (n, from(n)))
  .reduceLeft((a, b) => if(a._2 > b._2) a else b)._1

assert(r == 837799) // 1 s

def f(row: Seq[Long], c: Int): Long = {
  var s = 0L
  val next = row.map { n => s += n; s }
  if(c == 0) next.last else f(next, c - 1)
}

def r(n: Int) = f(List.fill(n + 1)(1L), n - 1)

assert(r(20) == 137846528820L) // 1 ms

val r = BigInt(2).pow(1000).toString.view.map(_.asDigit).sum

assert(r == 1366) // 1 ms

val units = Array(0, 3, 3, 5, 4, 4, 3, 5, 5, 4, 3, 6, 6, 8, 8, 7, 
                  7, 9, 8, 8)

val tens = Array(0, 0, 6, 6, 5, 5, 5, 7, 6, 6)    

lazy val name: Int => Int = {
  case n if(n < 20) => units(n)
  case n if(n < 100) => 
    tens(n / 10) + (if(n % 10 > 0) units(n % 10) else 0)
  case n if(n < 1000) => 
    name(n / 100) + 7 + (if(n % 100 > 0) 3 + name(n % 100) else 0)
  case 1000 => 11
}

val r = (1 to 1000).map(name).sum

assert(r == 21124) // 1 ms

val s = """<raw input data"""

val grid = s.trim.split("\n").map(_.split("\\s+").map(_.toInt))

def f(rows: Array[Array[Int]], bottom:Seq[Int]): Int = {
  val ms = bottom.zip(bottom.tail).map(p => p._1 max p._2)
  val ss = rows.last.zip(ms).map(p => p._1 + p._2)
  if(ss.size == 1) ss.head else f(rows.init, ss)
}

val r = f(grid.init, grid.last)

assert(r == 1074) // 2 ms

val lengths = Array(31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 31, 31)

val ls = for(y <- 1900 to 2000; m <- 1 to 12) yield
  if(m == 2)
    if (if (y % 100 == 0) y % 400 == 0 else y % 4 == 0) 29 else 28 
  else 
    lengths(m - 1)

val fs = ls.foldLeft(List(1))((ws, l) => ((ws.head + l) % 7) :: ws)

val r = fs.count(_ == 0)

assert(r == 171) // 2 ms

def f(n: BigInt): BigInt = if(n < 2) 1 else n * f(n - 1)

val r = f(100).toString.view.map(_.asDigit).sum

assert(r == 648) // 1 ms

val ds = (0 until 10000).view
         .map(n => (1 to (n / 2)).filter(n % _ == 0).sum)

val as = ds.zipWithIndex.collect { 
  case (n, i) if n < 10000 && ds(n) != n && ds(n) == i => i
}

val r = as.sum

assert(r == 31626) // 658 ms

val r = io.Source.fromFile("names.txt").mkString.split(",")
        .map(_.init.tail).sorted.map(_.map(_ - 64).sum)
        .zipWithIndex.map(p => p._1 * (p._2 + 1)).sum

assert(r == 871198282) // 38 ms

val as = (0 to 28123).map(n => (1 until n).filter(n % _ == 0).sum)
          .zipWithIndex.filter(p => p._1 > p._2).map(_._2)

val exc = as.view.flatMap { a => 
  as.takeWhile(_ <= (28123 - a)).map(a +)
} 

val r = (1 to 28123 diff exc).sum 

assert(r == 4179871) // 9 s

def ps(s: String): Seq[String] = if(s.size == 1) Seq(s) else 
  s.flatMap(c => ps(s.filterNot(_ == c)).map(c +))

val r = ps("0123456789")(999999).toLong

assert(r == 2783915460L) // 7 s

lazy val fs: Stream[BigInt] = 
  0 #:: 1 #:: fs.zip(fs.tail).map(p => p._1 + p._2)

val r = fs.view.takeWhile(_.toString.length < 1000).size

assert(r == 4782) // 468 ms

val ps = (2 until 1000).map(i => (1 to 2000)
         .find(BigInt(10).modPow(_, i) == 1)) 

val r = 2 + ps.indexOf(Some(ps.flatten.max)) 

assert(r == 983) // 2 s

lazy val ps: Stream[Int] = 2 #:: Stream.from(3).filter(i =>
  ps.takeWhile(j => j * j <= i).forall(i % _ > 0))

def isPrime(n: Int) = ps.view.takeWhile(_ <= n).contains(n)

val ns = (-999 until 1000).flatMap { a => 
  (-999 until 1000).map(b => (a, b, (0 to 1000).view
    .takeWhile(n => isPrime(n * n + a * n + b)).size))
}

val t = ns.reduceLeft((a, b) => if(a._3 > b._3) a else b)

val r = t._1 * t._2

assert(r == -59231) // 6 s

def cs(n: Int, p: Int): Stream[Int] = 
  (n * 4 + p * 10) #:: cs(n + p * 4, p + 2)

val r = 1 + cs(1, 2).take(500).sum

assert(r == 669171001) // 1 ms

val r = (2 to 100).flatMap(a => (2 to 100)
        .map(b => BigInt(a).pow(b))).distinct.size

assert(r == 9183) // 17 ms

def max(d: Int) = math.pow(10, d).toInt - 1

def sum(n: Int) = n.toString.map(_.asDigit)
  .map(math.pow(_, 5).toInt).sum

val limit = Stream.from(1).find(d => max(d) > sum(max(d))).get

val r = (2 to max(limit)).view.filter(n => n == sum(n)).sum

assert(r == 443839) // 2 s

def f(ms: List[Int], n: Int): Int = ms match {
  case h :: t =>
    if (h > n) 0 else if (n == h) 1 else f(ms, n - h) + f(t, n)
  case _ => 0
}

val r = f(List(1, 2, 5, 10, 20, 50, 100, 200), 200)

assert(r == 73682) // 15 ms

val ms = for {
  a <- 2 to 10000; b <- 2 to 10000 / a
  m = a * b; s = a.toString + b + m
  if s.length == 9 && (1 to 9).mkString.forall(s.contains(_))
} yield m

val r = ms.distinct.sum

assert(r == 45228) // 73 ms

val rs = for(i <- 1 to 9; j <- (i + 1) to 9; k <- 1 to 9; 
  if k * (9 * i + j) == 10 * i * j) yield (10 * i + j, 10 * j + k)

val p = rs.reduceLeft((n, d) => (n._1 * d._1, n._2 * d._2))

def gcd(n: Int, d: Int): Int = if (d == 0) n else gcd(d, n % d)

val r = p._2 / gcd(p._1, p._2)

assert(r == 100) // 5 ms

Sleeptracker monitors your movements while you sleep and wakes you up at a time, when you are in an almost-awake state, so that you wake up easily and feeling refreshed. Moreover, Sleeptracker Pro allows to upload your sleep data to a computer for analysis that helps you to improve your sleep habits.

I considered the watch as a good investment despite the price, because I am really awful at waking up. Does the product come up to the expectations aroused by the manufacturer’s promises? My experience shows that, although Sleeptracker Pro have a few shortcomings, the watch does what it claims.

How it works

Sleep cycle is what makes Sleeptracker possible. Sleeping is not a steady state, but a series of cycles that occurs throughout the night. Here is a sketchy graph of a typical adult sleep pattern (from the product manual):

Each cycle comprises different stages with different conditions of body and mind. That is why some waking up moments are better than others. So, if the alarm goes off while you are in an “almost-awake” state, you will wake up on the right side of the bed.

Despite the vague claim, that Sleeptracker “monitors signals from your body that indicate whether you are asleep or awake”, the only thing measured by the watch is movements of your arm. Sleeptracker uses a built-in accelerometer as a sensor to determine speed and direction of your motions. It is a potential drawback of the device, because accelerometer may be insufficient to reliable detect sleep phases, although it may be enough to merely register awake moments (usually, sleep stages and other characteristics of sleep measured by polysomnography, that includes simultaneous monitoring of brain waves, eye movements, hearth rhythm and muscle activity).

Exterior

The watch comes in an unpretentious box, the package contains:

• the device,
• a fancy connector,
• printed manual,
• CD with PC software.

The watch is big and heavy, with small monochrome display on a moderately large face:

The device has two buttons on each side:

On the back of the watch there are: battery cover, communication contacts and labels (one of which promises water resistance to a depth of 10 meters):

The display includes current time, day, date, and alarm settings:

The watch has a back-lit:

The way the device connects to a computer is rather unusual:

Usage

Although you can wear Sleeptracker anytime, it only needs to be worn at night to be effective. The face of the watch must be on top of your wrist, and the band must be tight enough to suppress movements of the wrist inside the band.

There are four buttons to configure Sleeptracker and any of them can be used together with the backlit to interact with the watch in the dark.

Unlike ordinary alarm clocks, Sleeptracker uses two parameters to specify the wake-up time:

• ALARM TIME – the latest moment to wake you up.
• ALARM WINDOW – a period (before the alarm time), Sleeptracker uses to detect the optimal moments at which to trigger the alarm (default window is 20 minutes).

Besides, if you want Sleeptracker to record your sleep data, you should properly set TO BED TIME. After that time, the watch starts recording your sleep patterns. The device supports “button shortcut” to easily adjust this parameter at 30 minutes after the current time.

You can choose alarm type from the following:

• ringing alarm;
• vibrating alarm;
• ringing-and-vibrating alarm.

The alarm is activated at your first almost-awake moment within the ALARM WINDOW. If no almost-awake moments found, the alarm is finally triggered right at the ALARM TIME (as an ordinary alarm clock does).

You have two ways to deal with the ringing/vibrating alarm, you can:

• turn it off;
• snooze it until the default ALARM TIME.

After waking up you may review your sleep data. The watch shows all recorded almost-awake moments for the recent night. You can see when those moments occurred in chronological order as DATA 1, DATA 2, etc.

The average time between the almost-awake moments is called DATA-A, and aimed to determine how soundly you have slept (the greater DATA-A indicates the better sleep).

Sleeptracker Pro supports uploading the sleep data to the computer, so that you can track your sleep history and identify factors that may be affecting your sleep. Provided software supports only Microsoft Windows operating systems. A cable with the clip is a USB-to-COM adapter, that requires a special driver (packaged with the software).

To transfer the sleep data of a recent night, you need to do the following:

1. Attach the included cable to your PC.
2. Set the watch to the DATA screen.
3. Connect the watch to the cable by inserting the clip into the holes on the back of the watch.
4. Open Sleeptracker Pro software and add a new sleep event.

The software also allows you to manually enter your sleep data without connecting the watch to the computer.

The main window of the program contains the following:

• Date column – shows the date of each night.
• Sleep chart – the horizontal lines show the time you went to bed, when you woke up, and how long you slept; vertical ticks mark almost-awake moments.
• Mood column – indicates the mood you were in when you woke up.
• Data-A column – shows the average time between almost-awake moments.
• Factors column – lists circumstances that may have affected your sleep.
• Averages chart – shows your sleep averages based on all nights you have added.

You may customize the display of your sleep data by changing the period of view or by hiding certain categories of data.

My experience

I have already been using Sleeptracker Pro for more than a month, and I have mixed feelings about the device.

The idea behind the product is great, but it is not a silver bullet. Although Sleeptracker performs better than an ordinary alarm clock, waking up is still waking up (at least for me). Many times I successfully slept through the alarm because I didn’t feel much aspiration to leave a bed.

The design of the watch is hardly practical. While most people don’t want their alarm clock to be waterproof, Sleeptracker Pro is waterproof, and that is why it looks a bit clumpy (heavy sealed case with a lot of metal, tight buttons and a small display). It’s not very comfortable to wear such a device at night, also, I doubt that someone consider using Sleeptracker Pro as a day-to-day watch (particularly, because of bright orange strips on the wristband).

Still, the main drawback of Sleeptracker Pro is oversimplification:

• The device only stores one night’s data, and if you forget to acquire the data on a day, you lose it.
• The watch doesn’t detect the moment when you actually fall asleep, so if you want to record the sleep data, you have to predict and set that time by yourself (often I update that setting several times in one night).
• Included software is rather old-fashioned, and has limited analytical capability.

Nevertheless, the watch works as promised and I definitely feel the difference. Most times I was waking up feeling refreshed and ready to take on the day.

The ability to record sleep history proved to be valuable, but I avoid using the bundled software for synchronization and prefer to type night’s recordings into an OpenOffice.org spreadsheet (later I am going to develop my own program to store and analyze the data).

Vibrating alarm is an awesome bonus: waking up is definitely more pleasant without audible alarm. Moreover, for the first time I have a truly personal alarm that doesn’t awake the whole house (except me).

Conclusion

The idea behind the product is great, while the implementation leaves much to be desired. However, the device does what it is marketed for, and Sleeptracker Pro can actually improve the quality of your life.

Update: Take a look at SleepArchiver – a cross-platform data manager for Sleeptracker-series watches.

Player matters

Audiobooks and podcasts become very popular medium of information. One cause of such popularity is a fact, that audio material, by its nature, has many advantages over text. However, an important reason for audiobooks spread is the creation of portable audio players.

Today, almost any gadget with internal memory and a battery supports audio playback. You can use a mobile phone, a communicator, PDA or a music player to listen to podcast or audiobook.

Personally, I enjoy listening to audiobooks and podcasts for many years. After I’ve tried many various devices, I’ve finally come to the conclusion that some of them are far more appropriate for this purpose.

Newer isn’t better

Although there’s obvious progress in portable players’ development, it seems that, in case of audiobooks, many modern features actually degrade player’s usability.

Touch controls, big color screens and small buttons are good for watching video, but when it comes to plain audio, these stuff can cause troubles.

Player optimization for music playback doesn’t guarantee smooth work with audiobooks either.

The perfect player

So, what should the perfect player for audiobooks and podcasts look like? Based on my personal experience, I defined the following must-have features for such a player:

• Bookmarks support
• Proper search support
• Tactile control
• Large monochrome display with landscape orientation
• Enough storage capacity
• Good file browser

Bookmarks support

Proper bookmarks support is a foundation stone. Without it, you can’t correctly resume the playback after a shutdown or a track change – you have to remember files you are listening to and current position for every file to restore it later. Needles to say, it’s not very exciting experience, especially in a case of a poorly implemented search (in that case, you’re obliged to hold “fast forward” or “rewind” button for minutes to find the right position in a large audio file).

I distinguish the following types of bookmarks support:

• Player correctly resumes audio playback after shutdown.
• Player restores position of playback on per-file basis.
• Player has capacity to add any number of bookmarks for any file.

The absolute minimum is a capacity to resume playback where you left off after turning the player off and then on. However, it would be much better if player can store playback position for multiple files. Such an ability helps a lot when you listen to different books and podcasts at a time (or when you alternate audiobooks with music). These are two kinds of automatic bookmarks support.

Support for manual bookmarking is a different way to resume playback, which has its own pros and cons. The advantages are that you can manually mark a file to quickly return to it later (without searching through a file system), also, you can store multiple bookmarks for the same file. The disadvantage is you have to do more actions by yourself (which is usually error-prone).

Which type of bookmarking support is better? It seems that automatic bookmarking is suitable for listening to podcasts (because each podcast is usually represented by only one file), and support for manual bookmarking is a convenient feature for audiobooks (to remember current files). Certainly, it’s better to have both.

Proper search support

Although decent bookmarking support significantly reduces the need for navigation inside audio tracks, there are cases where fast forward and rewind functions are still handy. For instance, you can use them to do the following:

• repeat the last sentence;
• omit an unwanted episode;
• skip a commercial insertion;
• find a particular place inside audio file (in case you have no bookmark).

Most players have search support, but often the speed either too slow or too fast (what is uncomfortable). An adjustable search speed is a partial solution, because any selected speed is constant, while preferable speeds for different action vary. (i. e. you may want a slow speed to repeat a phrase, and a fast one to find a particular episode).

Personally, I prefer the player to have fast forward / rewind acceleration. Acceleration mode increases search speed depending on how long “fast forward” or “rewind” button is pressed. This gives, on the one hand, means to easily skip small portions of audio, and, on the other hand, a tool for fast navigation inside long tracks. Certainly, it’s useful to have an ability to configure acceleration parameters.

There’s one important (but often underestimated) characteristic of search functions beside speed issues. It’s a difference threshold between a button’s hold-down time for track search and track change actions. The larger threshold is, the more likely you are to choose next or previous track instead of fast-forwarding or rewinding (so you have to select your file again and restore the precise position inside it). No doubt, only a player with clear distinction between search and track change actions can save you from going mad and tearing your hair out.

Tactile control

When you listen to audiobook or podcast it’s likely you have to control your player more frequently than when you listen to music. Speech is a more subtle entity comparing to the music – often you need to pause the playback for a moment, repeat the sentence, skip a commercial insertion, raise or lower the volume, change the track, etc… Who wants to bother removing the player from a pocket or interrupting pleasant rest just to operate a brand-new touchscreen (or a touch wheel)?

Tactile control implies the following:

• Player has palpable controls (like buttons) for all basic actions.
• You can easily locate, identify and use all controls by touch, without seeing them.
• You can operate all controls using one hand only.
• It’s unlikely to activate any control unintentionally.

Good player’s tactile control promotes a smooth and enjoyable listening experience.

Large monochrome display with landscape orientation

Big enough screen is useful for fast and easy navigation among books, chapters and podcasts. Landscape orientation of the screen gives more horizontal resolution in order to avoid annoying titles scrolling.

Although colors on screen look cool, it’s no surprise that color display is a pointless feature for pure audio player. Monochrome display, on the contrary, is comfortable for the eyes and has no problems with visibility in a bright light.

Enough storage capacity

Why is the player’s capacity important? Usually, a typical audiobook consumes more storage space than an average album of music. Besides, it’s handy to store all chapters of audiobook together. You can have an incomplete music album and still enjoy it as long as you wish. But, as for audiobook’s chapters, sooner or later you will need every one of them.

Personally, I don’t like to update player’s memory every time I’m going to listen to the next part of an audiobook. Also, I have a habit to listen to many audiobooks at a time, and, depending on my mood, to add podcasts or music to my listening. That’s why I consider storage capacity important.

Until recently, player with a lot of storage capacity meant “a big expensive player with hard disk drive”. But, fortunately, because of a flash memory prices drop, today we can find handy and inexpensive portable players with 4-16GB flash memory inside. Apparently, such capacity is enough for comfortable listening to audiobooks and podcasts.

If you intend to interchange large amounts of audio material, you may also consider using player with memory card slot for removable flash cards (like microSD). Many up-to-date players support removable cards, although such support is often bounded by 2GB or 4GB card limitation.

Good file browser

Some players show all audio files in a single flat list, what is by no means suitable for listening to audiobooks. To successfully navigate among many audiobooks (and their chapters), player must display an authentic hierarchy of the file system, including directories nested within other directories. It’s better to avoid limits either in the numbers of directories on the same level, or in the level of nesting.

Metadata tags (like ID3 tags) are a controversial issue. They can hold additional information about audio file beside the content of a filename. Sometimes that can be useful, but:

• it is harder to edit tags than the name of file,
• tags are intended for music and therefore store properties, directly inapplicable to audiobooks and podcasts (such as “artist”, “album”, “genre” and so on),
• displaying of excess metadata requires scrolling,
• often audio files lack tag information or include incorrect tags.

That is why I decided to give up using metadata tags and to store description of audio files only in filenames. Usually, I assign short but meaningful names to podcasts immediately before downloading.

It is up to you whether to relay on tags, however, you can avoid a great deal of confusion in this matter by choosing portable player with optional metadata tags’ usage.

Miscellaneous features

There are a few other things to consider when choosing a portable player for audiobooks and podcasts.

Player should allow to play audio files by directory structure (don’t reorder them by metadata tags). Support for continuous playing through a sequence of directories is essential to handle audiobooks divided in separate folders.

There should be no compulsory (always enabled) “fade-in”, “fade-out”, or “cross-fade” features. Obviously, they are not compatible with speech.

Player should supports many audio formats (like mp3, wma, ogg, mp4, flac, etc). Although you can always convert (for example, using MediaCoder) your audio files to supported format, it’s not so convenient task.

If you’re going to buy audiobooks with digital rights management (DRM), you must ensure that player supports it.

Conclusion

I laid down the basic guidelines for choosing portable player for audiobooks and podcasts. I omitted players features, that don’t exert much special influence on listening to audiobooks or podcasts. They are:

• design of the player (size, shape, weight, color, etc),
• type of the storage (HDD or flash),
• type and capacity of a battery,
• external interface (mini-USB or some proprietary one),
• speed of files transfer,
• quality of sound,
• sound processing capabilities (like equalizer),
• operating systems support,
• price.

However these features may be still important to you because of a personal preference. All need to be weighed before making a decision. That’s why, unfortunately, there’s no perfect player for everyone.

As for me, I have five portable audio players (not counting mobile phone, PDA and Sony Reader), and all of them are far from ideal (from my point of view, of course). Next player I am going to buy is one with Rockbox support.

Rockbox is an open source firmware for many digital audio players. It aims to be considerably more functional and efficient than stock firmwares while remaining easy to use and customizable. At the moment, it looks like it’s the only software that good for listening to audiobooks and podcasts. Everything you need to use Rockbox is to have a supported player.

I hope the information will be useful to you. If you have suggestions for extending or improving the article, feel free to contact me.