seagreen

> "business is an exchange of documents"

Did you just make up this phrase? It's really good!

  the so-called "reliability" offered by FP is can be attributed
  to comparable simple tasks these developers work on

  The kind of complexity I'm referring to is the need to synchronize
  and coordinate concurrency in a time efficient manner[..]

There's more than one kind of complexity. Keeping 1.3 million SLOC of trading code relatively error free while allowing non-full-time programmers to contribute to it is also complex.

  FP and OOP are both just tools, how you use them is
  way more important than which tool you choose.

I agree with this. I would note though that experienced developers don't always consider them equivalent tools, for instance Carmack suggests defaulting to FP when possible (from here: http://www.gamasutra.com/view/news/169296/Indepth_Functional...):

" No matter what language you work in, programming in a functional style provides benefits. You should do it whenever it is convenient, and you should think hard about the decision when it isn't convenient. "

Come on frozenport, do you really think that applies to Standard Chartered, Jane Street, or FB?

The good haskellers I've talked to about this say Haskell has only recently become a mature language=)

The modern fast data structures packages date from 2007 to 2011 (containers, vector, text, and unordered-containers).

Recently there have been more breakthroughs like FB adoption and an unrivaled web API library in Servant (https://haskell-servant.readthedocs.io/).

Also we got Stackage and Stack recently (which ended "cabal hell"). Even "cabal hell" is gone with the new cabal-install improvements.

So don't count Haskell out too easily because it's old. It's an awesome language, but it took people a long time to figure out how to program well in it, given that it's so different from the normal way of doing things.

  I have 2 issues with this [..] I don't read stuff on data 
  structures to amuse myself. I want it to be as succint and 
  to the point as possible and not waste my time kidding 
  around.

Someone should write a serious data structures book for you. Oh wait, they have, there are literally hundreds of them.

If you're attacking a topic with your full attention then you want maximum information as fast as possible.

If you're tired on a friday and want to learn something and have fun then information density doesn't matter anymore.

  Dumb question time: Aren't 95% of these use cases more  
  easily implemented with a single central source of truth, 
  possibly with distributed read-only replicas?

Absolutely. The tech press loves its fancy new craziness. Good engineering should be exciting enough (if they want to write about something cool they could write about immutable databases like Datomic), but no . . . _blockchain_!

The parent comment said criticisms of private day traders were motivated by jealousy, and I said that's certainly not the case for the most notable of the critics. Buffett could have made his success as a rodeo clown for all it matters to my point.

  It seems that many people that we all know do become quite 
  rich as investors, and the secret to their good fortune is 
  not apparent. Studies promising us "they'll all lose in 
  the long run!" makes us feel good about our decision not 
  to participate in the game.

This would be a way stronger argument if the king of the buy-index-fund team wasn't Warren Buffett:)

I don't think so, that looks like the setup I'd like to be using if I was on a more traditional distro.

One issue might be the handling of dependencies: does `yaourt -Qe` list everything you have installed or only programs you've given a specific command to install?

The great things about NixOS is that you can describe the entire state of your system in configuration files, and then after running `rebuild` know that what's on your computer _exactly_ matches that configuration.

Can you do that with containers?

For instance, I'm on NixOS `16.09.git.20f009d (Flounder)`. Here's my configuration: https://github.com/seagreen/vivaine. I know my machine exactly matches the combination of that NixOS version + those config files. My impression is that this is messier with containers because while you can make a snapshot and know the snapshot is frozen, as you modify snapshots over time they'll begin accumulating cruft due to things like installing programs, uninstalling them, snapshotting, but still having some leftovers from the install. I'd like to hear from someone with more container experience here though.

1.6 "Monad Type Class" was fixed in GHC 7.10!

Some of these complaints are goofy like the one about the naming of Functor.

Others like the one about records being bad are perfectly legitimate. It would be awesome to see real improvement on this. Unnecessary runtime errors are evil.

  As someone who writes Go every day for work, 
  I can't agree that Go is simple.

You may be confusing "simple" with "good". A simple solution to a complex problem may not be a good one. Go can be simple and still not a great solution because it pushes complexity to a higher level.

JS and CSS are obviously super messy, but that's a whole different issue.

I'm thinking more of cases like letting people write some HTML in a local notetaking program or something like that -- what's a nice subset of tags you should give them so they can make text look good, but doesn't commit you to supporting the lovecraftian being that's the entire HTML spec?

Also your last line made me laugh. Nice delivery=)

I'd like access to JSON Schema's impressive tooling. I haven't seen anything like this for SQL schemas: http://jeremydorn.com/json-editor/

(Though if it exists please tell me, I'd be very interested!)

I think it would be useful in various situations.

In my particular case clients of different quality are connecting to a local datastore. I'd like to make sure that even if they mess up validation the data in the store still matches the schemas it claims to. Of course, I could have them connect to a local process instead and have that process handle validation before the data goes in the store, but it's always nice to avoid intermediaries.

Slick, thanks!

I just want a key/value JSON database with schematization. If that's "trying to hammer a screw" then so be it.

Awesome, I had no idea they'd added that!

I don't think so -- I'm looking for a database that will actually enforce a JSON schema for you -- I don't think Postgres has any built-in support for JSON schematization.

I could always do validation before inserting data, but that opens me up to error on my side which I'd like to avoid=)

Has there been any work at all done on staking out workable subsets of HTML? I looked around a fair amount a while ago and the closest thing I could find was AMP.

I think this is an important issue because the HTML spec is crazy long and it would be awesome for new technologies (say a new desktop GUI library or whatever) to be able to say "we allow and will interpret this subset some HTML" without committing to the entire byzantine spec.

Are there any key/value JSON databases that enforce JSON Schema (or some other schema language)? That seems way better to me in situations where you actually care about data integrity.

Uh oh, this is pretty convincing=)

Thanks, this is encouraging.

Looks like I've got a choice to make (all on NixOS):

+ Stick with NeoVim and hope one of the Intero ports to that editor takes off (as I understand it there are a couple right now)

+ Switch to Emacs+Evil+Intero. I've never used Emacs before (even with Evil) so it would be a little work.

If someone more up-to-date on the situation has advice that would be awesome:)

Can you tell us some about the technology you're using? I'm curious if a newfangled immutable database like datomic would be a good fit for medical recods. Also, do you do any schema'ing besides what's provided by your database (JSON Schema/XML Schema/etc)?

I don't think you need to worry, I'm sure that who's familiar with PureScript also knows it's more recent than Nix.

Those PureScript records tho...

Well, you would use records, but records are a weak point of the Haskell language. I've discussed "why not Haskell" with some Nix people and they specifically mentioned the lack of row polymorphism.

But as Haskellers we _are_ concerned about unsafePerformIO et al. -- this is why we have the SAFE pragma.

Content-addressed / append-only / strongly typed

that looks _perfect_.

Can you talk about how you handle linking to the latest version of a piece of data? Since the latest version may always be changing you can't use a hash for that. Git uses branches (which it mutates, so I know you're not following that model exactly). My personal opinion is that each piece of data should get a non-human readable, random ID -- that way there's never any incentive to change it because it can never become inaccurate -- but I'm curious what you came up with.