stream_fusion

React and jsx constructed dom using inline-styles brings the disparate technologies together in a composable way.

Also, I don't think 23&Me's test results have enough medical value to be used for evaluating health risks.

Insurance companies would have another view.

Can anyone compare and contrast flux, reflux and redux?

I have got the hang of writing flux stores - and like the uni-directional dataflow model a lot. I also evaluated relay/graphql - which unfortunately is missing backend support for my relational db for the moment.

It feels like I need some experience with all the patterns/frameworks before it's possible to be confident about choosing and investing time writing code.

As someone who spends most of my time in vim/ screen/ tmux I moved to xmonad recently as well (albeit on debian).

It felt very liberating to suddenly be free of all the Gnome3 / Unity politics, developer fragmentation, and complex desktop systems that still feel inferior to the commercial OS-X/Windows alternatives.

It's arguably faster and of more benefit to learn OO in an OO language, and then work backwards to figure out ways to implement those strategies in C (eg. polymorphism using structs with arrays of function pointers, or win32 send_message constructs).

It's similar with functional programming. Figuring out folds, pattern matching and monads is probably easiest in haskell or Ocaml/F#. The decision to apply those techniques in other languages without native support then becomes a judgement about the benefit.

I thought your analogy was spot on. In React, the view is reduced down to a functional projection of the model - rather than being a complicated set of state interaction patterns (eg. mvc,mvvm). The React framework then handles the real DOM update - in the same way that a Monadic IO computation is not executed directly - but instead is passed to the Haskell IO runtime to be executed.

The problem with Java binaries on the client, was that the Java applet didn't have direct access to the DOM bindings.

Instead, the applet rendered it's own GUI via the plugin, and the look and behavior was inconsistent with the rest of the browser experience.

A similar story with activex and flash.

It's a mystery why it has taken so long to get to the point where we can target the browser with a statically-checked higher-level language that has API access to the native browser event loop and dom components the same way that Javascript does it.

There's an intention is to transition ethereum from proof of work, to proof of stake, to avoid some of the mining centralization and waste.

I can make 20 or 30 commits during some code changes in a morning's worth of coding. This allows me to easily trace back to any point, or cross-reference changes across many local branches, etc.

At the end, it might all be squashed down into a single bug-fix commit for the devel branch.

The commit granularity that's desirable and effective for an individual is very different to the history you want in the main feature branches.

Thanks. I'll probably end up creating an unprovisioned partition. It's frustrating, exactly because of the uncertainty re future performance. Especially given the price premium for pro/enterprise level hardware.

I have the same drive in a laptop. There were lots of trim errors in the kernel logs, with debian so I ended up disabling trim.

I have one of the affected drives mentioned in the article in my development laptop - the Samsung SSD 850 PRO 512GB.

As one of the most expensive SSD drives available on the market, it was disconcerting to find dmesg -T showing trim errors, when the drive was mounted with the discard option. Research on mailing lists, indicated that the driver devs, believe it's a Samsung firmware issue.

Disabling trim in fstab, stopped the error messages. However it's difficult to get good information about whether drive performance or longevity may be impacted without the trim support.

An argument behind not increasing the block size, is that miners can price-ration the inclusion of transactions in blocks.

During periods of high network contention, an ordinary user can include a higher-fee to prioritize their transactions.

Correspondingly, the cost for attacking the network using spurious transactions will increase.

In the real world there is always a discord between requirements and reality, skillsets and the problem space, change management and the need for rapid change, scope creep, and on and on.

We follow Agile. At the beginning of iteration planning, the dev-team, has to task-out the items and score the complexity, and then decide the cut-off point as to what can and cannot be achieved within the 2 week iteration.

It's taken us several years, but this ruthless cycle of feedback, and responsibility has led us to a point, where we scope it right about 75% of the time.

Having also been involved in projects that have overrun deliverable dates by years - I wouldn't have believed it possible for a software-management process to work so well.

Of course it helps, that there is genuine philosophical buy-in, and that our revenue is derived from our software (eg. we're not a cost-centre).

Reverting a commit is trivial. There is zero opportunity of destroying a repo. From my notes,

# revert a commit

git revert dd61ab32

Not knowing the technical, or legal arrangements of SWIFT doesn't prevent one from making a traditional international wire-transfer.

Almost all languages have an escape-hatch to do dangerous stuff.

The key insight about Rust is the set of programming abstractions (linear types to manage resources) that enable one to get systems-like programming tasks done, without needing to fall back on very low-level coding techniques.

My experience playing around with KD trees is that they are super effective for multidimensional indexing (including spatial) and range search so long as the data is relatively static. The difficulty comes when trying to update and re-balance them dynamically, which is where other structures perform better.

Everyone who needs 'upsert' is forced to go and read those discussions (and probably a few more articles as well), and then implement their own version of the same thing many times over.

The fact that it's complicated is precisely the reason this ought to be solved for the general case.

Otherwise, Postgresql is still an awesome product.

npm can use server-side resources.

But where do you store the 25GB blockchain in a client-side full-node implementation?

Isn't this just an implementation only for Node?

My experience is that, Haskell syntax is a dream compared to Ocaml, with 'where' clauses, beautifully simple lambda syntax, do notation support, . and $ composition, typeclass operator overloading.

Ocaml is more practical in a hard to explain way. Much more predictable in terms of it's memory and cpu use with non-lazy default evaluation, and I found much better performing on general code.

Anybody that thinks the banking system is going to let a decentralized service pull money out of people's bank accounts...

I don't think that's completely clear. There will certainly be co-ordinated resistance from many entrenched interests, but that resistance also creates a profit-opportunity to break ranks to provide the service to customers who want it. It's more likely we'll see a split amongst banks and their policies to digital/alternative banking services.

They should carefully consider the possibility of creating a decentralized exchange (like bitshares or nubits) and not merely a new centralized exchange for a decentralized currency (bitcoin). There will be a future for blockchain technology that can eliminate MtGox type events.

CEO exercised right-of-reply to potentially tortious statements from the employee. Also public interest.

The context, is a spill-the-beans IAMA from a disgruntled ex-employee provocatively made on reddit itself.

The CEO has a right-of-reply and a duty to protect the reputation of the company against accusations, and he fairly exercised that right.

There was no slanging match, and the response consisted of a single post amongst hundreds in that thread.

I don't see a problem with having both positions made public after the ex-employee initiated the public confrontation. As always The truth is probably going to lie somewhere in the middle.

Does this change pattern matching syntax of recursive data structures, if every node is an explicit box type? Could be cumbersome for matching parse-trees?

The Rust trait/typesystem doesn't currently support higher kinded polymorphism.

It's often difficult to gain mindshare with other developers and management.

> You should typically not manage scarce resources such as file descriptors, network connections, and buffers or caches in a dealloc method. In particular, you should not design classes so that dealloc will be invoked when you think it will be invoked.

Do they propose an alternative mechanism to handling resources other than reference counting? As you state, RAII breaths life into c++, given how well it works for all types of resources.

It sounds like the above statement is possibly being made in anticipation of the introduction of garbage collection, which would make piggybacking resource destruction non-deterministic. Whereas, it could also be interpreted as a very strong reason to favor manual (maybe automatic) reference counting, and eschew GC entirely. I don't know objective-c very well, but I wonder if the use of GC has generated these arguments against it from within the OSX developer community.

If engineers could pursue nuclear power free from influence and interference, then I would have full confidence in their ability to create safe systems. Unfortunately politics and other forces have a way of always intruding.

Feynman's analysis of the Challenger disaster, and of the engineer who stayed up in the middle of the night refusing to sign-off on the launch in the face of commerical and political pressure ought to give anyone pause. In fact he was able to cite the exact reason for failure that occured - gaseous breach of the O-rings, due to operation outside design paramters. The fact his career was also finished, is the icing on the cake.

Chernobyl(cumulative maintenance procedural failures) and Fukushima (concrete walls too low to withstand the Tsunami) also stand as evidence that science and engineering doens't exist in a vaccum and always gets co-opted.