What a great solution. Very creative. Thank you for sharing that.
jsonify
drumusician
Hi All,
I’m also just starting out using Elixir coming from ruby and I was totally into the piping thing and created this solution:
http://exercism.io/submissions/d3b3fdf89fc245f0a1c81e277f359df8
After I looked at all the others I was a little confused as the approach of everybody else was totally different.
Would love to get some feedback on my solution to hear if I am totally going off on a wrong sidepath…
Thanks!
0
NobbZ
I gave some comments on the exercise directly, short version: pipes are cool, but use them wise.
1
drumusician
Thanks Norbert,
Basically could it be correct if I assume that you actually shouldn’t be piping with these conditionals as it is actually not about transforming data.
So in this case would pattern matching this solution be a more elixirian way of approaching this?
just tryong to wrap my head around these new concepts
1
NobbZ
It is not just an elixir thing. When working with some construct like cond you should alsways have short and concise conditions, which are easy to read and tell you not only how data has to look like, but what it actually means.
When you want to know if some property p of data is either true or false you really should give that property a proper name and make it a function suffixed by a questionmark and use it. Just consider how much better ends_in_questionmark?(input) reads compared to input |> String.replace(~r/[\s]/, "") |> String.replace(~r/[\d]/, "") |> String.last == "?", just consider how much question?(input) does even better suites the context of the exercise!
Katrina Owen (creator of exercism) gave some nice talks about refactoring in ruby, one of these talks was even about our friend bob: Katrina Owen – Overkill; 2014. There is much stuff one can transfer to elixir. Propably not the stuff about extracting into various classes, but it would make sense to extract the predicates into separate modules. Haven’t done it so far in my own solutions though, since I’ve watched Katrinas talks just 14 days ago.
2
f1st
nubunto
I’m confident that you meant:
defp shout_numbers?(message) do
message
|> String.upcase
|> String.ends_with?("?")
end
And, in:
You actually meant:
defp capitals_letters?(message) do
message
|> String.split(" ")
|> String.capitalize
|> Enum.join(" ")
end
If I’m mistaken or you corrected it already, I apologize.
2
dogweather
I believe that the top-level function (the cond) should be a restatement of the problem specification. It should be written using terms in the problem domain (teenagers) not the solution domain (whitespace, upper case, etc.). E.g.:
def hey(input) do
cond do
question?(input) -> "Sure."
yell?(input) -> "Whoa, chill out!"
nothing?(input) -> "Fine. Be that way!"
true -> "Whatever."
end
end
See how that code pretty much reads like the assignment for the problem. This is a big advantage of functional programming.
The implementation of these should then be done at gradually lower levels of abstraction. Here’s my solution: http://exercism.io/submissions/e7f0b1696ed14eaa99bc72bf882f2459
4
tyro
Hi @dogweather. I like your ‘hey’ function but have a few thoughts. Recently I’ve been coming round to the idea that, in general, fewer functions is better. Why? Because more functions = more surface area for your code which makes understanding/maintaining it more difficult. This view has been articulated (in some form) by Linus, Carmack, and Blow which lends it some credibility. That is not to say that monolithic, ginormous functions are good, but that perhaps programmers have been underestimating the costs of abstracting into multiple functions. Your solution has 7 functions. For contrast here’s my single-function solution:
defmodule Bob do
def hey(input) do
cond do
String.ends_with?(input, "?") -> "Sure."
String.upcase(input) == input and String.downcase(input) != input -> "Whoa, chill out!"
String.trim(input) == "" -> "Fine. Be that way!"
true -> "Whatever."
end
end
end
http://exercism.io/submissions/03d9b6c8dbba45f79ac817ecd356a65a.
This might be overthinking a simple exercism exercise, but that’s the point of them. To start discussion! 
0
NobbZ
Yeah, your solution is quite common throughout various tracks on exercism, but it has its drawbacks.
We do only have 4 cases here, of which one is a fallback, so we have 3 “real” cases. Now our customer chimes in and has a CR: “Change bobs reply to yelling to ‘NOT YELL AT ME’”.
Looking at your code it will take me a while to actually figure out which of the clauses does actually belong to yelling, but other solutions like @dogweather’s do give you proper hints were you need to change. They do not require you to understand the conditions, all you need to now is some plain english.
Very similar reasoning applies when there is a request to change the condition for a question. Which one belongs to questions here?
Extrtacting that conditions into predicates does increase readability and maintainability of the code alot. This applies even more on a larger codebase. And thats what exercism is about, giving small problems and requiring you to find solutions for that small problem that scale when the problem grows.
Especially for this exercise, there was a talk given by Katrina Own (founder of exercism), https://www.youtube.com/watch?v=qLpvc5r6Bb0 (I think this one was it, just waded through my browsers history and skimmed the video)
2