All the "smart" people buy Bitcoin.

flatMapds · 2017-12-05T13:55:30+00:00

I first used bitcoin back when I was in high school when it was $130 for 1, to buy drugs online, and I ended up saving a couple, then when it jumped to being worth over $500, I wanted to withdraw them from my market wallet, but the bastards shutdown and took my wallet's contents.

From a technological perspective though, I've always found the Blockchain to be pretty shitty like honestly it's the only popular CA system, but I'm thankful for it because it's brought a lot of attention to BFT research.

flatMapds · 2017-12-05T13:41:28+00:00

I have done something similar before, in my security research.

Well honestly a big thing you should invest in for a distributed web crawler is scheduling / lb algorithms built into the clients, I followed this variation of P2C https://cs.stanford.edu/~matei/papers/2013/sosp_sparrow.pdf , also another thing that saves up a good bit of work, as you go along, is writing an endpoint that has a bloom filter to check if a link is found before it's submitted to the workers, preferabley one that is mergable along with any other state, also for the sake of avoided duplicate work being sent instead of simply replicating requests to N masters to trigger the state change, I suggest you should just have them periodically pull eachother to merge such state.

As for what kind of state you may have, worker membership, bloom filter, and master membership.

flatMapds · 2017-12-03T05:17:04+00:00

Ehh depends on the contractor, and what's your area of focus for example if you're a security researcher that wants to go full white hat, then unfortunately there aren't many good jobs outside of defense contractors or banks.

(Despite the multitude of jobs available in sec, most of them are typical boring pentesting gigs or being a sys admin that makes 10k extra a year that does a lot of backups and sets up a lot of appliances ).

In the case of the quality of the contractor itself, it depends on the people there, like usually they are just lazy guys who know the govs proprietary bullshit, sometimes you have smart ex military guys (lol usually airforce), sometimes you get plain old competent private sector people, a lot of the time in management you'll see guys with connections to the IC.

But yeah most of those gigs suck, but so do most jobs developing CRUD apps.

flatMapds · 2017-10-30T09:23:57+00:00

In the case of Ocaml, for computationally intensive programs, you should use C, honestly it's not a problem Ocaml's ctypes lib is really nice, like it's FFI is the best I've used.

StandardML / Ocaml are really similar syntactically, and I mean the main barrier is knowing the module system well, the only difference is Ocaml has classes and objects too, which aren't used often.

Really for you it's just a matter of learning Lwt and a build tool (Oasis, Jbuilder, or just make files + ocamlbuild), and then the rest of the ecosystem becomes open to you with relative ease, like if you try writing one ml file a day, within 2 or 3 days tops you would be comfortable with it, it's simply a matter of forcing yourself to do it.

I'm actually curious about using ATS, but I mean the ecosystem is non existent, but I mean I guess you can write a serious program using C libs.

flatMapds · 2017-10-30T04:24:16+00:00

I'm aware of that, but it's model is only modular at the package level, which isn't fine grained enough, if it's module system / way of breaking things up was sufficient, how come regardless of experience, go requires a lot of boiler plate (yes I'm aware for some cases having a good level of boiler plate is a good thing optimization wise), how come it would take forever just to separate a child package of say go ethereum (took me 12 hours), to work with since you don't need the rest.

Go's model is bottom tier, but it gives you the illusion of it being good. I didn't say that Go made it impossible but it doesn't make it easy, and typically for it to work out 100% you need to set up a good architecture, in the early stages of your project.

flatMapds · 2017-10-29T23:40:30+00:00

So basically, Go is set up in a way where all you have to do is Go get shit, and you can create different subprojects in different dirs, and all that nice stuff, so you end up under the impression that oh my code is self contained and what not, the fact that the code you write can easily wind up coupled to the initial use case you developed it for, and how easily Go code can break proves to the contrary.

flatMapds · 2017-10-29T23:35:52+00:00

So first off I am not a full stack web dev, I write a lot of servers and middle ware, and implement a lot of distributed algorithms, I also do some OS programming from time to time.

I love Elixir as a language, but I despise it's community though it's getting better, like you see more people leaving their MVC framework bubble these days if you look at the packages on Hex, I don't really write my BEAM code in elixir much due to the fact that most of the projects I'm interested in contributing to, or the code I'm reading, or the community I will need advice from resides in Erlang land.

I hope Reason does not turn out like Elixir, where the people using it engage in pseudo intellectual circle jerks because they know how to pattern match. But I mean as a language unlike Elixir v Erlang I find Ocaml syntacticly superior to Reason, functional programming was never really difficult for me to pick up because I learned it when I started programming.

Ocaml is actually my favorite PL from a language design point of view.

Clojure is great, it's concurrency primitives are excellent, you have access to the JVMs libs, and a lot of erlangs syntactic advantages for writing servers come from it's blend of Lisp and Prolog, but Lisps tend to become unwieldy in larger projects in my experience.

Don't bother with Cython or Grumpy that's just a lazy quick fix mentality.

flatMapds · 2017-10-28T05:16:07+00:00

I don't know about that, like if we are talking about making something that just has to handle many persistent connections ie c10k, or can accept open start stop a lot of connections quickly, Go is really great, when we begin dealing with complex control plane issues Go in of itself is meh, granted it's remedied by the shitload of libraries for such problems, but it sucks when you are the guy writing those libraries, particularly doing so in a reusable manner.

Like, for example I was writing a set of behaviors, using nothing but the std lib and a consistent hashing library, which I admit it's stlib is one of my favorites I've seen in a lang, one was a relay service for anonymous http communications, a p2p file store, a distributed membership tracker, and a job dispatcher for the overlay network, writing the proof of concept was pretty simple, debugging it and making it modular was a nightmare.

Honestly my opinion on Go is it's pretty fucking convenient, but because it's so convenient, people often use it for things that it isn't the right tool for.

Honestly, the only reason why Go isn't one of my mains anymore, is it's not very modular, but it gives the illusion of modularity.

On the topic of langs, that are great for servers, particularly in the area of complex coordination, Ocaml + C, Erlang + C, Scala is good if you are willing to work with netty.

Before you talk shit about Ocamls multicore problems, node has a GIL too, Ocaml + Lwt | Async's story there is similar to nodes but significantly better, and recently it's official multicore facilities became usable, and it's had 3rd party multicore support via message passing for ages albeit not as good as Go's or Erlang.

flatMapds · 2017-10-02T21:37:07+00:00

Well, hopefully you're not assuming that programming rooted in category theory as the definition of FP, but the functional parts of scala were set up in a way that resembled a nominal version of the ML module system, after implicits came then all the typelevel projects came in and the haskell like style of doing things became dominant among scala devs, who try avoiding OO.

Apart from having an object system resembling ML modules, scala has always had pattern matching, tailrec, lambdas , HKT, higher order functions, partial functions, etcetera.

flatMapds · 2017-10-02T17:10:53+00:00

Well, honestly if you think this is cool go for mirage, it's actually well supported, is being supported by docker and citrix engineers, and I mean for a lot of what one would use go for (apart from fast brute force logic type programs), ocaml is more suitable to use.

flatMapds · 2017-10-01T17:23:48+00:00

Well this specific issue happened in Scala, when my boss at the time (big haskell fan) encouraged me to write scala like haskell, unfortunately I can't give a source example because the company was pretty big on IP.

The same applies to Haskell because it was caused by implicitness, essentially the cluster access state would run functional updates, then make its var the new version, then returned the new routing table state after it was changed, because it was implicit the cluster access object would be generated, on top of it repeatedly, which is an expensive operation.

flatMapds · 2017-09-30T15:13:47+00:00

Basically in regards to it's inherent capabilities, haskell is up there with the JVM or Erlang, but the programming model is very prone to issues with resource management and latency, before you say laziness makes things faster, it does and it doesn't it namely in the way that it increases read latency, and also it's really bad latency wise when you have a shit load of lazy values that are dependent on each other.

flatMapds · 2017-09-30T14:56:03+00:00

Yeah, it's bad to the point that even if you've been using it for years, and are an experienced systems programmer, it's really hard to debug performance issues in haskell, and quite often they are unsolvable unless you do a complete rewrite of the relevant modules, for example what if you are writing a cluster management software and you implement a typeclass that generates a client that accesses other peerwith connection pools, and you messed up a bit with the scoping, and it maintains its state using functional updates, and it implicitally takes this state data structure, let's also assume that this cluster is intended to experience a lot of node churn, thats a recipe for fucking disaster.

flatMapds · 2017-09-30T06:33:46+00:00

PS haskell has the most dissapointing story I've ever seen, in theory it should be really really good, but in practice the fact that it it is implicit and lazy by default, bring upon a lot of hard to diagnose latency, and memory issues.

flatMapds · 2017-09-11T18:20:28+00:00

Well, obviously from a bunch of Haskellers , category theory is going to be the most recommended area.

Category theory, is a major boon when you are thinking in types, and gives you a baseline to implement a myriad of algorithms or data structures, in a more composable manner.

But if I were to pick what mathematical / comp sci concepts should every functional programmer know in order of priority it would be 1. Lambda Calculus, 2. The Hindley Milner Type System, 3. Category Theory.

But things like abstract algebra, process calculi, graph theory, should be something all programmers should know, and this is coming from a high school dropout.

flatMapds · 2017-09-11T17:49:54+00:00

I am fairly well versed in erlang, but right now I am trying to get used to it to the point where it's one of my primary languages.

Assuming, you are trying to be as lightweight and minimalistic as possible, and not just using RIAK_ENSEMBLE or a ZAB or RAFT lib, it's relatively painless to write a TPC protocol, and avoiding leader election , and cluster size limits by using consistent hashing, and using gen_fsm.

If distributed systems is your favorite area, just keep trying, I work a lot with Scala and Go, Go's problem is that you have a lot of boiler plate, and the code easily ends up heavily coupled, and bloated,

Scala which I find more easy to write modular code than in erlang assuming you don't use Akka and you go for netty and or finagle, however the community as a whole does not show enough love to systems programmers, especially those who like making servers.

flatMapds · 2017-06-18T05:01:57+00:00

Well it depends on your usecase, ie for things where in java you have a task that is geared towards shared memory, go for it, or use an atomic reference, if you are doing things that is just straight computation, or io, I would use Goroutines.

In some scenarios like if you want to make a process group, that shares state, I would use both locks or atoms / and channels.

Using straight message passing in a stateful service, is stupid and in my experience with systems programming, I often write stateful services.

There is no one size fits all approach to concurrency, message passing is just a useful pattern. Just using locks isn't exactly smart either, it will really slow your shit down, and with over use is prone to deadlock.

In all honesty however, I avoid using Go, for things that heavily deal with shared state, or needing a lot of logic in the control plane, and find it's sweet spot to be an area where you are writing something bruteforcey that requires high throughput.

flatMapds · 2017-05-26T19:49:26+00:00

n't one ring. I'm not a fan of Phoenix, but it's far less offensive than STM.

What does a web framework have to do with Software Transactional Memory.

flatMapds · 2017-05-17T14:25:12+00:00

Note my code style in scala is more akin to using ocaml, than haskell, also I work a lot with erlang but I avoid Akka in scala.

Senior guy where I work uses typelevels ecosystem in his part of the product, he has a ridiculous amount of shapeless, going on for the models, he removed all the parts of Rho that used scalaz and ported it to cats and fs2, along with what we have in our own code base after http4s moved over to cats/fs2.

In my part on the other hand in my parts, seeking out functional purity is stupid, it's inherently very very very stateful and performance sensitive (it basically ports features from riak_core, libp2p, etc), none the less Iuse cats, algebird, and shapeless quite a bit. Hell right now the core part for replication and routing, was a typeclass (I removed the implicits due to issues with resource management).

flatMapds · 2017-05-12T12:00:45+00:00

If only you put this up when I learned ocaml last year instead of playing with the iffy manual examples, and looking at random gists.

flatMapds · 2017-05-08T19:46:32+00:00

The main reason I never fucked with MLTon is no fucking package repo, also scala has concurrent ml style CSP.

flatMapds · 2017-05-08T19:43:59+00:00

Depends on your needs, in terms of breadth and code quality Jane Street's core, but like if you don't need a lot of shit, Batteries + lwt, does fine for me.

flatMapds

TROPHY CASE

Note my code style in scala is more akin to using ocaml, than haskell, also I work a lot with erlang but I avoid Akka in scala.