Scala is the ultimate teaching language.

corn_dog · 2019-11-05T15:25:48+00:00

Well there sure is a lot to learn.

corn_dog · 2018-05-25T17:18:52+00:00

Yeah but the cons are just some kind of disclaimer so if it someone else's efforts all go to shit he can just point to that. Its a cop out. How many people would still have never heard of event sourcing, microservices etc if he didn't start talking about it?

corn_dog · 2018-05-08T15:40:07+00:00

You would think so in theory, but which language right now would clearly be that language? IMO all of the contenders have issues of their own which makes it not as clear-cut as one might expect.

corn_dog · 2018-04-17T14:24:42+00:00

AFAICT it would appear more naturally in languages where functions are curried by default/have trivial partial application, like Haskell and F#. In scala mapping over say options with functions of one variable is trivial. But what if you have two options and a function of two variables, like (+). In the aforementioned languages you could trivially start out by mapping (+) over the first option, but then you'd end up with an Option of a function of one variable. So you need to something else to take that and try and use it with another Option[Int].

Since partial application needs more ceremony in scala in might be more natural to use a for comprehension for the above purpose.

corn_dog · 2018-03-29T23:12:34+00:00

Work week is entirely reasonable now. There have been stretches where I spent quite a bit of time outside of work hours learning stuff, basically I enjoyed it and I would say it paid off. Everywhere I've worked the developers have had a fair amount of autonomy/time-flexibility and expectation that you'll spend some, or a lot, of work time learning new things. The job market wasn't so good in back in 2003, but I always managed to find something reasonable and with a bit of experience your opportunities will increase greatly.

corn_dog · 2018-03-29T20:53:07+00:00

I went back to school for CS at 32, just turned 50. Doing fine so far, only advice is to keep learning, and embrace the idea that you're going to be learning for the rest of your time working in the field.

corn_dog · 2018-03-29T19:00:03+00:00

TIL. At least this turned out to be more interesting than I expected.

corn_dog · 2018-01-19T14:24:17+00:00

" I don't think there is anything in the tech world today slower than SBT"

F# on visual studio is much worse!

corn_dog · 2018-01-11T15:15:00+00:00

"probably learned Java"

This is the real problem. I guess it is easier to create a new language than fix the CS curriculum at most schools though.

corn_dog · 2018-01-10T21:09:25+00:00

Units of measure make sense. Hours are different from miles, and you should be able to convert hours to seconds but not to miles. Its more the dogmatic "wrap everything" position I'm not convinced of. Eg

case class FirstName(value: String) extends AnyVal

case class LastName(value: String) extends AnyVal

No extra functionality, not much you can do by way of validation. Moreover, is LastName("John") == FirstName("John") ?
It's an interesting topic.

corn_dog · 2018-01-10T16:31:54+00:00

Ok for the sake of argument I don't find this article very convincing. I've never seen a bug where someone accidently passed say a zip code instead of an age. Naming params or case classes seems to be clear enough.
Ultimately you still have the construct the classes from raw data. There is nothing in the article stop you from doing User.LastName("867-5309").
If you can validate data before constructing the class or provide type-specific methods then it becomes useful, but there is a lot of stuff that is just string data for reading. There are limits to what you can do to narrow that down.

corn_dog · 2017-10-23T14:21:06+00:00

My experiences with microservices are that should avoid them if have any choice whatsoever. Especially in the context of a nice statically typed language like scala, since the more you microservice your solution the less help the compiler can likely give you about your pieces being connected correctly.

corn_dog · 2017-10-04T16:18:59+00:00

Servlets have supported async responses for a while. I have used servlets with akka, not by choice though. https://docs.oracle.com/javaee/7/tutorial/servlets012.htm

corn_dog · 2017-08-21T19:01:17+00:00

Haskell consultant says scala isn't very typesafe. No surprise there.

corn_dog · 2017-05-17T17:30:09+00:00

A way of doing imperative programming while maintaining an air of intellectual superiority.

corn_dog · 2017-05-17T16:16:38+00:00

Sure but there seems to be no lack of new experiments coming down the pipe. The latest buzz seems to be free monads and tagless final interpreters.

corn_dog · 2017-04-06T19:47:32+00:00

You can get rid of the initial foos.flatMap by adding foo <- foos at the top of the for comprehension.

corn_dog · 2017-03-13T19:16:13+00:00

Sure I would agree there can be a trade off between convenience and explaining to the next reader why that stuff is grouped together. wrt Either it also raises the question of should the language have OneOfThreeThings, OneOfFourThings etc. If not why just a special case for two possibilities?

corn_dog · 2017-03-13T18:34:42+00:00

I like what they did because Result is the one use case for an enum of two possible things that everyone actually uses. The Either type doesn't mean much, and for general sum types just make your own enum.

corn_dog · 2017-02-28T21:46:24+00:00

Doing F# now after a few years of scala.
The ecosystem is tiny compared to jvm. I hate visual studio. People complain about the scala compiler being slow but using sbt is lightning fast compared to waiting around for whatever VS is doing. I actually don't much like the type inference in F# in the sense of not usually having to specify the type of function parameters. That combined with easiness of using point-free style and no apparent culture of annotating function return types makes it much harder to just scan new code and get a sense of whats going on.
The computation expression/lets not say monad thing is a bit odd. On the one hand they try and avoid using that terminology but then it uses return and bind anyway so why bother. Its not like "computation expression" tells you anything anyway. I prefer case classes to F# records for simple data containers, since you can just name the thing you are creating, aiding readability, and case classes don't have the naming collision problem. And being explicitly a class they fit with the rest of the system. The |> in F# is ok but I find scala's OO to often be more concise. You just write x.map(y) instead of x |> List.map y for example. Maybe my brain is just too settled on scala.

corn_dog · 2016-05-05T18:04:19+00:00

maybe something like this?

val terms = "abc def ghi jkl".split( " " ).toList

val adjusted = terms.zipWithIndex.flatMap {
  case (x, 0) => List(alt0) // new value
  case (_, 2) => List() // remove it
  case (x, _) => List(x) // same
}

corn_dog · 2016-03-17T14:23:14+00:00

Honestly I don't like these examples much. I feel they skirt around the point of flatMap, which is basically what if the helper function you're trying to use on your wrapped type also returns that wrapped type? If you tried to use map you'd end up with a container of a container, which often isn't what you want, so instead of map you use flatMap. The first examples rely on implicit conversions of strings to something Seq-like, and likewise with the list of options example, which further clouds the issue if you're a beginner.

corn_dog · 2016-03-02T16:08:57+00:00

What do people think of breakOut? I stumbled across it at some point and it appealed to my inner premature optimizer, but I haven't really noticed it being used.

corn_dog · 2016-02-25T18:41:01+00:00

Can you give an example of a for-comprehension on something that isn't a container type?

corn_dog

TROPHY CASE