On the contrary, when you can move your complexity into the type system, the. You have just taught your compiler how to check that you are using things correctly, and that is insanely useful in large scale software.
Well, it’s been paying my wages for the past eight years, so it’s incredibly useful to me. Are we services “very specific projects”? Are data processing systems? Are geospatial data munging? Are financial systems? Those all sound like mundane, every day projects, and they’re exactly what I’ve been working on.
And when it comes to “actual work”, that’s where Haskell truly shines - being able to fearless refactor code and iterate until the compiler is happy again is my favourite feature of Haskell. It’s not the “neat type system”, it’s the ability to not have to keep the entire project in my head at absolutely all times because I might forget to make a stupid change the compiler should have caught for me. The productivity is massive, once you’ve invested the time, but it does take time and it is an investment.
This argument is literally “the documentation for this domain I don’t understand is bad because I refuse to learn the domain”.
I use the lens library all the time and those docs make perfect sense, particularly if you apply just the teensiest bit of logic and thing “Could a setter, perhaps, set something?”. It’s a DSL, and you don’t understand the domain - I’m sure you’d have a great time explaining this function from LLVM without referring to any other part of the documentation to give it context https://llvm.org/doxygen/group__LLVMCCoreValueInstructionGet.... What’s a GEP? Under the rules you’re applying to the lens documentation, I’m not allowed to look that up, because it should be immediately obvious.
I couldn’t agree with this opinion less - lens is incredibly elegant, and very consistent. It is a DSL, and you need to spend some time learning the domain, but once you do you’ll find it hard to live without it. If that’s the way you use the library then you haven’t spent any time to learn how to use it.
I’m sorry, but this is an astoundingly ridiculous point of view. Those type variables CAN’T be named anything better because they could be absolutely anything at all, that’s the point of generic types.
You are complaining that a single function within a library doesn’t describe the whole abstraction the library is built on? Should every single function, operator and type include the whole fucking lens tutorial so you don’t have to go and find it?
I suppose every web library should include an explanation of IP, TCP, UDP, HTTPS, url encoding, compression and anything else that is needed, on every single function too? Christ, I cannot believe how incredibly dumb your take here is. Libraries in every single language provide some kind of preamble in their documentation which covers what abstraction that library provides, and Haskell is no different; the particular library you have chosen to misunderstand is INCREDIBLY general, the documentation is actually amazingly precise, if you have taken the time to learn what an optic is.
I genuinely think you should be ashamed of this opinion, because it shows that you’re both willingly ignorant, and proud to state that fact publicly.
Stick any structure in DynamoDB and you’ve already halved your nesting depth due to its encoding a superset off JSON in JSON. Then start encoding more complex structures like the ones the others have mentioned and these limitations start to bite pretty quickly.
The Haskell library safe-money does a great job of handling these weird cases for currencies. It has a separation between the types used for calculations and storage/presentation, and lets you define arbitrary ones so in your example you can handle computations in an arbitrary precision rational representation and then store it in cents and later convert with proper rounding to 5 cent increments if necessary. Much of this is handled by the type system, including type safe currency conversion.
Does anyone know how this relates to the new ARM pointer validation stuff Apple just shipped on the XS? I haven't seen much press about this except on Risky Biz.
Even if this doesn’t increase security, you should still do it in the hope the user will check the username they’ve just typed as well as retyping the password.
So you think that calling out someone who makes (very) public, demonstrably false statements for pretty clear personal gain is internet bullying? I would call it being held to account - what sane society would listen to such a ridiculous story and not call it the bullshit it obviously is? Allowing that to happen would lead to a society where fantastic lies are the norm and you’d never know if you could trust anything anyone would say.
If I made statements saying that not only did I discover, but also made love to and raised the children of a dragon to international media, do you think it would be bullying for people to tell me it’s nonsense? If so, you’d have a pretty spectacular definition of bullying if you ask me. We should not allow liars to go unchecked.
This page made my iPhone 5S really sad, scrolling was really laggy - i'm guessing all the clojure code was using something like clojurescript? If so, it really didn't need to as it was all static but causes a seemingly really large amount of computation while scrolling.
Trifecta is best used via the parsers library, which is fairly well documented. This also (in theory) allows you to switch which parser you use between trifecta, parsec, attoparsec and even ReadP. I say in theory because the the semantics of these libraries differ.
Mark Hibberd gave a great talk at Yow! LambdaJam this yeah on writing mundane code in Haskell, with a tutorial on writing a shell. The code can be found on https://github.com/markhibberd/xsh and the talk should be on YouTube in the near future (I hope).
Recursion is only a bad idea in languages with poor support for recursion, it's not difficult to write efficient Haskell code which produces good assembly with fairly obvious recursive algorithms. Optimisations like stream fusion and libraries like foldl also contribute to really good code generation (not guaranteed and also not generally applicable optimisations, but certainly helpful)
Gotta talk to those subs somehow, those ultra long wavelength Comms aren't exactly high bandwidth. (I'm just making this up but it feels plausible, at least a few decades ago)
Just because something uses ARM doesn't mean it'll be easy to target, there's a hell of a lot more to getting something running on an embedded system than just what basic architecture it supports.
I guess that my point was that for the situations where the built in syntax in OO languages is used, the lens alternative is usually at most about 2 characters longer, which is hardly more inconvenient.
On the contrary, lenses are far more powerful than what's available in JavaScript and all other OO languages. Traversals and Prisms give so much power that's lacking in OO
Wind power is already cheaper than coal, at least in Australia, even when you ignore the cost of building the coal plant (it's been way cheaper for a long time if you factor in the initial construction cost), and solar will soon reach the same crossover point.
Yeah I'm sorry this is complete nonsense, this is exactly how it works and has always worked. If Google pays for renewables to be produced, uses some energy that happened to be produced at a coal plant but someone else uses the energy from the solar/wind farm, then the benefit of using renewables has been materialised. It's not a hard concept, but somehow people struggle with the idea.
I don't agree it is deceptive, if Google paid for 1GW of renewable electricity to be generated and 1GW is contributed to the grid from renewable sources then everything is as it should be. If the EMF that gets to Google's servers happens to be provided by a nearby coal plant they have still caused 1GW to be produced by renewables. This is how the grid works, and how it has always worked, it's just that no one in the past has cared if it was coal, gas, hydro or something else they were getting it from. Organisations are now willing to pay a small premium to use an equal amount of energy as renewables are generated. Storage matters for the long term goal of a zero emissions grid, but is not necessary for the economics to work out and the benefits to be felt.
For something as fundamental as a container library, GPL will basically mean it's not used widely. There's a reason many language ecosystems generally use BSD/MIT licences for almost all libraries (haskell being just one example I know this to be true for). Applications may be another story.