I hate Scala
-
@jaloopa oh, ha ha ha.
-
@dkf said in I hate Scala:
@gąska said in I hate Scala:
Any combination of methods, any number of calls, any number of threads scheduled over any number of cores in any order. Without any mutexes. When you have pure functions, you can do it just fine and not worry about any race conditions.
Not quite. You've still got the essential requirement of some functions (not all!) for the values that they operate on to exist before they can be evaluated. That imposes some ordering on evaluation, and that means that values have actually got to be synched into memory visible to the other threads, and that in turn requires more expensive CPU operations (memory barriers, etc).
But it's usually all hidden behind several layers of abtraction, so that the average programmer never has to touch any of this. You run several tasks, and they run in total isolation (or what looks like and works like total isolation) from each other, and only point of synchronization is thread joining in a strict parent-child hierarchy. Of course it might be too expensive performance-wise in some cases, but for most stuff it's perfect.
-
@gąska "Better" in what sense? What makes it better?
"Functional programming" just seems to be a couple of vague concepts strung together by people that don't really understand programming.
-
@bulb said in I hate Scala:
I couldn't even find a way to do a conditional configuration section it it.
Profiles. It's a while since I did anything with the activation rules for them (other than by explicitly selecting them for the build), but they're totally how you do conditional config.
-
@gordonjcp said in I hate Scala:
"Functional programming" just seems to be a couple of vague concepts strung together by people that don't really understand programming.
The core of it is programming done by people who really really wish it was all just math. Some of those people are competent enough to make their desire a reality. However it is very much not a silver bullet; it solves some problems better and others worse. If your problem is intrinsically connected to mutable state, functional programming doesn't sit very nicely with it. (FP can describe things that can be interpreted as if it was mutating state, but it all gets messy the more you're dealing with something where the statefulness is a key part of the problem domain.)
-
@dkf That actually makes a lot of sense. Most of the code I write these days is mutating a shitload of state, possibly tens of thousands of values every handful of microseconds, based on the previous state of those values And A Bunch Of Other Stuff. It looks like Functional Programming is designed to not let you do that kind of thing, which is why it doesn't really fit in my head.
-
And there is the pesky bit about data having to reside somewhere, so the input/output comes from some sort of data storage, usually a database. And you get the same concurrency issues with data in the database as you get in code when you just have oodles of threads that grab some bit and fondle it and put it back.
-
@carnage said in I hate Scala:
when you just have oodles of threads that grab some bit and fondle it
I like that description. :D
-
@gordonjcp said in I hate Scala:
@gąska "Better" in what sense? What makes it better?
"Functional programming" just seems to be a couple of vague concepts strung together by people that don't really understand programming.
Well, yeah, it is a bunch of unrelated concepts strung together. But each of them provides huge benefits.
- Pure functions: not possible everywhere, but by making most of your code purely functional (which is totally doable despite what naysayers say) you make your codebase highly parallelizible.
- Value objects and value semantics makes it easier to reason about complex data structures. Every copy is (semantically) a deep copy; altering local variable doesn't alter anything outside the function; when writing generics, you don't need to write separate code for primitives and complex objects.
- Standard library built from the ground up on the above properties. Necessary if you want them to be actually useful (e.g. pure functions cannot call impure functions, so if your stdlib is mostly impure, you can't do almost anything interesting).
- A powerful type system with strong type inference, allowing you to build some very neat abstractions. A double-edged sword, but when used correctly, it makes code much easier to write (mostly because you have to write less) and more bug-proof (for the same reason).
None of the above is specific only to functional languages, but only functional languages tend to get them all at once, with good enough ergonomics to be usable in practice. Although in recent years, imperative languages have been pushing in this direction more and more, which makes me happy because most classic functional languages (LISP, ML and their derivatives) are royal PITA in practice.
-
@gąska When you say "purely functional", what exactly does that mean?
-
@ixvedeusi said in I hate Scala:
@gąska said in I hate Scala:
in 2008 it was WPF and JavaFX with their XML-like languages where you just said what controls you want your window to have and how the data is filled in, and poof! A complete frontend that Just Works™!
IMHO this is not a "functional" approach, this is a "declarative" approach. Though I see how that might integrate with functional programming, it's still a different concept.
There's a lot in common between declarative and functional programming. Personally, I use the following rule: if you have to directly define computation formula, it's functional, otherwise it's declarative. In XAML case, I'd say the layout part is declarative and the data binding part is functional, though others might disagree. The line is really blurred.
It's also IME extremely programmer-hostile as soon as you want to do anything for which there is no pre-made out-of-the-box ready-to-use solution.
Yes, although it's more of the declarative part's fault rather than the functional part.
In spite of all your assurances, I still don't see how functional programming would apply to UI. By its very essence, a UI is an interface which allows the user to change the program's state by issuing commands; by it's very nature it's stateful and imperative. I can't think of a single UI which would not fit this description.
You can't make all of GUI functional. That's obvious. But you can make a huge part of your GUI functional. Let's pick the typica model of GUI applications: the MVVM, where your program is split into View, ViewModel, Model, and BusinessRules (the part of Model where you do all the computation, without the part storing final data). With such split, only the Model contains independent mutable data (ie. data that's not computed from other data), so you can make the View, the ViewModel and BusinessRules almost entirely functional (the last one can be modeled as a function of current state and user input into the new state).
For me, the biggest strength of functional programming is that it composes very well with imperative programming (though only in one way), which allows for gradual transition, doesn't force you to use it for parts where it doesn't make sense, and you can reap the benefits even if only a small part of your code is functional.
-
@gordonjcp said in I hate Scala:
@gąska When you say "purely functional", what exactly does that mean?
It means using only pure functions.
-
@gąska Okay, and in turn, what does that mean? I don't understand the concept enough to translate it into something I can google.
I mean, everything I've read so far seems to suggest that a "pure function" is one that does not accept any input and does not act on any output, which doesn't make a whole lot of sense to me, but I suspect I just don't translate the terms properly.
-
@gąska said in I hate Scala:
Value objects and value semantics makes it easier to reason about complex data structures.
FWIW, this is very very true. The key is that it prevents spooky action at a distance problem: it means that if you've got a value, you know exactly what value you've got and nobody else is going to pull the rug out from under your feet. It's what I miss most when writing Python code; Python's hugely not about letting you have this.
-
@gąska said in I hate Scala:
@gąska When you say "purely functional", what exactly does that mean?
It means using only pure functions.
AKA programs which don't actually do anything
@gordonjcp said in I hate Scala:
"pure function" is one that does not accept any input and does not act on any output
Not quite: a pure function's only input is its arguments, and its only output is its return value. No globals, no hidden config flags, no I/O, no writing to the screen or any other outputs ("side effects"). Also a pure function cannot "modify its arguments" as you'd do with pass-by-reference. Thus at the call site you can always know for sure what the function will do (and what it will return) just from the local context.
-
@gordonjcp A pure function depends only on its inputs and produces only its outputs (or return values), without affecting or being affected by any other state.
Among other benefits, you can run many of them in parallel since they never interact with each other, and you can cache (or "memoize", similar to but not the same as "memorize") the outputs for given inputs and avoid having to run them again.
Among other detriments, it can't perform any input or output on its own, since that changes global state. Some other "impure" function has to handle any interaction with the outside world, including loading values to be used as input, and saving whatever values get output.
-
@dkf said in I hate Scala:
It's what I miss most when writing Python code; Python's hugely not about letting you have this.
Can you expand on that? I was of the impression you can write functional code in Python just fine.
-
@gordonjcp a pure function is a function whose only inputs are its arguments and only outputs are return values. In particular, it doesn't use global mutable state, it doesn't change the mutable state, and it doesn't depend on the environment it runs in. The consequences are that running such a function doesn't alter the state of the system in any way (running it and discarding the result is effectively no-op), and running it with same inputs always produces the same outputs. These properties make them easily composable, easily testable and easily parallizible.
The drawback is, since it can't alter the environment, it can only call functions that also don't alter the environment - in other words, pure functions can only call other pure functions. This limitation is not a problem in mostly pure functional codebase, but is serious issue in mostly impure one. The less pure functions you have, the less useful pure functions are.
Another thing (which pisses off functional fanatics) is that pure functions cannot do IO. However, they can process all your I and prepare all your O, so only a very small part of your code actually has to be impure.
-
-
@topspin said in I hate Scala:
@dkf said in I hate Scala:
It's what I miss most when writing Python code; Python's hugely not about letting you have this.
Can you expand on that? I was of the impression you can write functional code in Python just fine.
Reference semantics. Shallow copy by default. You have to be really careful not to modify something else by accident. For example, Python 2 (maybe 3 too?) has (had?) this problem that if you had default value for a function argument, you'd need to remember to copy it before returning or modifying because otherwise you'd modify your default value.
-
@mrl said in I hate Scala:
@gąska said in I hate Scala:
@gordonjcp a pure function is a function whose
Huh?
"Of which" doesn't work as good in some contexts.
-
@jaloopa said in I hate Scala:
By that definition, isn't JavaScript functional?
Yes but no.
Meaning: yes it can be used as a functional language, but no its single-threaded nature prevents most optimizations you'd gain from doing that from working correctly.
(Although to be fair, most C# programs with LINQ statements are doing them in a single thread. C# doesn't have to do them in a single thread though. JavaScript does.)
-
@gąska said in I hate Scala:
@mrl said in I hate Scala:
@gąska said in I hate Scala:
@gordonjcp a pure function is a function whose
Huh?
"Of which" doesn't work as good in some contexts.
I meant to ask what polish word/phrase fits that requirement.
-
@gąska said in I hate Scala:
Pure functions: not possible everywhere, but by making most of your code purely functional (which is totally doable despite what naysayers say) you make your codebase highly parallelizible.
I don't think anybody's argued you can't make any given program purely functional (well, with your priviso that "no side effects" doesn't actually mean "no side effects" when functional programming pundits say it). I think the argument is that it's not suited for all types of programs and would make a spaghetti mess.
@gąska said in I hate Scala:
Value objects and value semantics makes it easier to reason about complex data structures. Every copy is (semantically) a deep copy; altering local variable doesn't alter anything outside the function; when writing generics, you don't need to write separate code for primitives and complex objects.
For example, what if your complex data structure is the entirety of Tamriel in Elder Scrolls Online? Just making a single copy of that would slow your game's framerate to zip zero nilch.
And lots of languages have generics.
@gąska said in I hate Scala:
Standard library built from the ground up on the above properties. Necessary if you want them to be actually useful (e.g. pure functions cannot call impure functions, so if your stdlib is mostly impure, you can't do almost anything interesting).
Every language that isn't C# already has an utter garbage standard library, and C#'s isn't all that great either.
@gąska said in I hate Scala:
A powerful type system with strong type inference, allowing you to build some very neat abstractions. A double-edged sword, but when used correctly, it makes code much easier to write (mostly because you have to write less) and more bug-proof (for the same reason).
My preference is to have zero or nearly-zero type inference.
@gąska said in I hate Scala:
with good enough ergonomics to be usable in practice.
Really? What's the functional language equivalent of Visual Studio? I kind of assumed they were the usual text-based "we love 1986" bullshit you get with most programming stuff outside Microsoft products.
@gąska said in I hate Scala:
Although in recent years, imperative languages have been pushing in this direction more and more, which makes me happy because most classic functional languages (LISP, ML and their derivatives) are royal PITA in practice.
That's why I said way above the best compromise is to add functional stuff (where it shines) to existing languages like, once again, C# did a decade ago.
-
@gąska I don't really see why that would be useful or desirable, but I guess some folk do.
So you're just constantly copying and re-copying data, until what? You make a new copy of the data once you've worked on it, and destroy the old?
I can't really think of any functions I use that don't handle masses of input and output simultaneously, or are specifically designed to mutate a large chunk of data.
I guess functional programming is just not something that's going to fit what I do.
-
@blakeyrat said in I hate Scala:
What's the functional language equivalent of Visual Studio?
F# in VS?
-
@mrl said in I hate Scala:
@gąska said in I hate Scala:
@mrl said in I hate Scala:
@gąska said in I hate Scala:
@gordonjcp a pure function is a function whose
Huh?
"Of which" doesn't work as good in some contexts.
I meant to ask what polish word/phrase fits that requirement.
In this case, it's "który", which lacks this split.
-
@gordonjcp said in I hate Scala:
I don't really see why that would be useful or desirable, but I guess some folk do.
As I said above an actual "purely functional" program cannot actually do anything, because it can't change the state of your computer; so yeah, in the very strictest sense it's not useful.
The main idea in practical, real-world functional programming is to identify exactly which parts of your program manipulate state, and isolate that part out (that's where people start talking about "monads"). This is in practice often a rather small part of the progam and usually provided by the OS / standard library. The entire remainder of the program, which has to determine what output to generate according to the input, can be implemented in a purely functional style, and this does have some very useful advantages.
One advantage is that you can find out what a function returns / produces entirely by just looking at the function itself; you know there's no "hidden state" anywhere which could change that. It's also much easier to write tests for the functions, because you know exactly what they are supposed to do and what their results depend on; you don't need to "mock" an entire environment because pure functions don't depend on environment.
Another advantage, as already has been pointed out, is that pure functions are trivially parallelizable; just run them in parallel, they have no way of interacting with each other, so no race conditions, no need for synchronization etc.
At least that's the theory. Each of these advantages has some serious "caveats" which may or may not surface in a particular application. It appears that some problems are very well suited to this approach, others not at all.
-
@blakeyrat said in I hate Scala:
I don't think anybody's argued you can't make any given program purely functional (well, with your priviso that "no side effects" doesn't actually mean "no side effects" when functional programming pundits say it). I think the argument is that it's not suited for all types of programs and would make a spaghetti mess.
My argument is that you ABSOLUTELY CANNOT have entire program purely functional, but it can be used for great majority of code in great majority of domains.
@gąska said in I hate Scala:
Value objects and value semantics makes it easier to reason about complex data structures. Every copy is (semantically) a deep copy; altering local variable doesn't alter anything outside the function; when writing generics, you don't need to write separate code for primitives and complex objects.
For example, what if your complex data structure is the entirety of Tamriel in Elder Scrolls Online?
That's why I said "semantically". Actual implementations of functional languages make extensive use of copy-on-write, copy ellision, and many other optimizations that significantly reduce amount of copying that actually occurs. Of course it'll never be as performant as hand-written C++, but then neither is C# or any other bytecode language. The performance is "good enough" for almost all types of applications, and performance gains from other areas (caching/memoization, higher parallelism) might outweigh these losses.
And lots of languages have generics.
But not higher-kinded generics. You can't make
Foo<T>that instantiatesT<int>and passListto it.@gąska said in I hate Scala:
Standard library built from the ground up on the above properties. Necessary if you want them to be actually useful (e.g. pure functions cannot call impure functions, so if your stdlib is mostly impure, you can't do almost anything interesting).
Every language that isn't C# already has an utter garbage standard library, and C#'s isn't all that great either.
So? I only said it has to be functional, ie. make it easy to write in functional style, ie. have most features as pure functions.
@gąska said in I hate Scala:
A powerful type system with strong type inference, allowing you to build some very neat abstractions. A double-edged sword, but when used correctly, it makes code much easier to write (mostly because you have to write less) and more bug-proof (for the same reason).
My preference is to have zero or nearly-zero type inference.
So you never use
var?@gąska said in I hate Scala:
with good enough ergonomics to be usable in practice.
Really? What's the functional language equivalent of Visual Studio?
What's the C# equivalent of Elder Scrolls Online? Clearly C# sucks!
Just because no one has done something it doesn't mean it can't be done. Everything done was not-done once upon the time.
Also, I'm not the advocate of functional languages. They all suck. I'm the advocate of functional PARADIGM, and only for where it's practical. Which is 90% of all code.
That's why I said way above the best compromise is to add functional stuff (where it shines) to existing languages like, once again, C# did a decade ago.
Me too! But C# has still a very long way to go.
-
@gąska said in I hate Scala:
So you never use var?
I guess I meant to say "implicit type conversion", which is what I thought you meant. Meaning: treating a char as an int if you compare it to an int.
varI'm ok with if and only if I'm in an IDE where I can mouseover and get the real type when I need it.@gąska said in I hate Scala:
What's the C# equivalent of Elder Scrolls Online? Clearly C# sucks!
I dunno; ReCore's in C#, it's a pretty massive AAA game. Admittedly not ESO large though.
@gąska said in I hate Scala:
Just because no one has done something it doesn't mean it can't be done.
Right but if moving to functional programming makes my tools suck now, what's my incentive? Like why would you even start selling this until the tools stop sucking? (I know; I know: open source-y "release early, release often!" Then again Python and Ruby have been around for decades and still have no decent IDEs. Go figure.)
@gąska said in I hate Scala:
Me too! But C# has still a very long way to go.
What do you think they should add next?
-
@gordonjcp said in I hate Scala:
So you're just constantly copying and re-copying data, until what? You make a new copy of the data once you've worked on it, and destroy the old?
Conceptually, yes. In practice, a lot of copies get optimized.
I can't really think of any functions I use that don't handle masses of input and output simultaneously, or are specifically designed to mutate a large chunk of data.
I think you are deeply confused about what I said. When I say "can't do IO", I mean the very very very bottom of call stack, the very very very end of procedure. All IO processing that's not literally putting data on disk/in buffer/through socket, isn't IO but processing, and processing totally can be done in pure functional way.
-
@gąska said in I hate Scala:
@mrl said in I hate Scala:
@gąska said in I hate Scala:
@mrl said in I hate Scala:
@gąska said in I hate Scala:
@gordonjcp a pure function is a function whose
Huh?
"Of which" doesn't work as good in some contexts.
I meant to ask what polish word/phrase fits that requirement.
In this case, it's "który", which lacks this split.
What? "Który" means exactly "which" - it can be applied to persons as well as objects and doesn't indicate possession.
-
This post is deleted!
-
@mrl said in I hate Scala:
@gąska said in I hate Scala:
@mrl said in I hate Scala:
@gąska said in I hate Scala:
@mrl said in I hate Scala:
@gąska said in I hate Scala:
@gordonjcp a pure function is a function whose
Huh?
"Of which" doesn't work as good in some contexts.
I meant to ask what polish word/phrase fits that requirement.
In this case, it's "który", which lacks this split.
What? "Który" means exactly "which" - it can be applied to persons as well as objects and doesn't indicate possession.
Sorry, I meant "którego".
-
@gąska said in I hate Scala:
Of course it'll never be as performant as hand-written C++, but then neither is C# or any other bytecode language.
You'd be surprised at how much faster a bytecode language can be in some circumstances. It's not that a C++ program couldn't get up to those speeds, but sometimes it is extremely non-obvious how to actually do it.
-
@dkf I'm not. But Blakey and many others would certainly be surprised about performance of purely functional languages.
-
@gąska Performance is like number 47,543,145,865 on my list when selecting a programming language.
-
@blakeyrat you were the one who introduced video games into discussion!
-
@gąska said in I hate Scala:
@mrl said in I hate Scala:
@gąska said in I hate Scala:
@mrl said in I hate Scala:
@gąska said in I hate Scala:
@mrl said in I hate Scala:
@gąska said in I hate Scala:
@gordonjcp a pure function is a function whose
Huh?
"Of which" doesn't work as good in some contexts.
I meant to ask what polish word/phrase fits that requirement.
In this case, it's "który", which lacks this split.
What? "Który" means exactly "which" - it can be applied to persons as well as objects and doesn't indicate possession.
Sorry, I meant "którego".
Where's my dickweedery badge? It's all I came here for.
-
@blakeyrat said in I hate Scala:
Every language that isn't C# already has an utter garbage standard library, and C#'s isn't all that great either.
But C#'s garbage gets collected.
-
@blakeyrat said in I hate Scala:
What do you think they should add next?
"If I had asked people what they wanted, they would have said faster horses."
-
@dkf said in I hate Scala:
@bulb said in I hate Scala:
I couldn't even find a way to do a conditional configuration section it it.
Profiles. It's a while since I did anything with the activation rules for them (other than by explicitly selecting them for the build), but they're totally how you do conditional config.
I can have profiles with various sets of configuration values. That's great. But than I need to configure a plugin this way if the current profile defines this and that way if it defines that. And that I couldn't find.
-
@bulb said in I hate Scala:
I can have profiles with various sets of configuration values. That's great. But than I need to configure a plugin this way if the current profile defines this and that way if it defines that. And that I couldn't find.
IIRC, you put the configurations of the plugins inside the relevant section of the profiles. This is an example cribbed from an old project of mine.
<profiles> <profile> <id>nosec</id> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-war-plugin</artifactId> <configuration> <webXml>src/main/webapp/WEB-INF/web-nosec.xml</webXm </configuration> </plugin> </plugins> </build> </profile> </profiles>With this, if I turn on the
nosecprofile, it configures the plugin that builds a WAR to use a non-defaultweb.xml(which would disable security requirements for the web app so that things were suitable for one of our nastier and more heavily-firewalled deployments). I don't remember if it lets you override only some parts of the configuration section for a plugin or not; I didn't need that sort of thing in this project. I also had different profiles depending on what platform the system was being built to support (because there were a few pieces of code which were very OS-linked as they tangled with the guts of secure program invocation) but the bits to turn those on were incredibly boring.I know that there's ways to configure profiles to be automatically activated in some circumstances, but I didn't use that.
-
@dkf Thanks… now only if it was obvious how the configurations are going to be merged (that plugin has a bunch of named (as in, each has an id subtag) configuration objects)…
-
@bulb I can't remember whether configurations are merged or whether it's done by wholesale overwriting. (Searches…) OK, there's some moderately complex controls available for what is going on; elements are inherited by default but you can specify what you want on a per-config-element basis by attributes.
I really have no idea what happens when profiles are also injecting. It's probably sensible, but I've not delved in that deep. :smiling_face_with_open_mouth_closed_eyes:
-
@mrl said in I hate Scala:
@gąska said in I hate Scala:
@mrl said in I hate Scala:
@gąska said in I hate Scala:
@mrl said in I hate Scala:
@gąska said in I hate Scala:
@mrl said in I hate Scala:
@gąska said in I hate Scala:
@gordonjcp a pure function is a function whose
Huh?
"Of which" doesn't work as good in some contexts.
I meant to ask what polish word/phrase fits that requirement.
In this case, it's "który", which lacks this split.
What? "Który" means exactly "which" - it can be applied to persons as well as objects and doesn't indicate possession.
Sorry, I meant "którego".
Where's my dickweedery badge? It's all I came here for.
Here you go:
-
@gąska said in I hate Scala:
Most software developers graduate universities.
Citation Please. This does not match experiences I have had involving thousands of developers during informal polls [conferences, clients, etc.]
-
@gąska said in I hate Scala:
Most software developers graduate universities. One of the courses that are always taught to CS majors in every college is functional programming in at least one language. We are literally doing what you say we should do, and have been doing it for years already!
@thecpuwizard said in I hate Scala:
Citation Please. This does not match experiences I have had involving thousands of developers during informal polls [conferences, clients, etc.]
I would add that of those who did go to college, many did not major in computer science.
-
@thecpuwizard so, I googled for data and it turns out that I was wrong:
Two out of three developers are self-taught, and other trends from a survey of 56,033 coders
Five extra years in school offer less of a financial boost than you'd think.
Which makes me even more pissed at my failure to find a job in the US, because it means that out of possible reasons - lack of degree, 3 years of experience not being enough, my resume using wrong template, people not understanding my accent, widespread anti-Polish racism - it most likely wasn't the first one.
-
@gąska said in I hate Scala:
@thecpuwizard so, I googled for data and it turns out that I was wrong:
Two out of three developers are self-taught, and other trends from a survey of 56,033 coders
Five extra years in school offer less of a financial boost than you'd think.
Which makes me even more pissed at my failure to find a job Cin the US, because it probably means that out of possible reasons - lack of degree, 3 years of experience not being enough, my resume using wrong template, people not understanding my accent, widespread anti-Polish racism - it most likely wasn't the first one.
Indeed. A "Bad" resume (including just the format/template) can be a killer. 3 years of experience may be limiting, but should not be a killer. Accents can be an issue. I have not seen any evidence of specifically anti-Polish racism [side note: I used to live pretty close to "Polish Town USA" ;) ].
On the flip side, I do still run into "issues" as I do not have a degree. Now consider:
- My degree would have been from 1981 or 1982.
- My degree would have been in Physics
- I have over 40 years professional experience
- I am providing corporate consulting services
Sometimes, it is just not worth trying to understand....
