"In the past couple days, dozens of people have shared with me their own favourite Terminal one-liners and scripts. I’ve learned new tricks about the tools I covered in my article, and discovered others I’d rarely or never touched. In fact, the best thing about the reaction to my article wasn’t the feedback directed at the post, my blog, or myself; it was the discussion that spawned all around the Mac-o-sphere about the command line and how to make the most of it.
I’m going to highlight a few of the more interesting utilities I missed in this post. "
"The OS X Terminal opens up a world of powerful UNIX utilities and scripts. If you’re migrating from Linux, you’ll find many familiar commands work the way you expect. But power users often aren’t aware that OS X comes with a number of its own text-based utilities not found on any other operating system. Learning about these Mac-only programs can make you more productive on the command line and help you bridge the gap between UNIX and your Mac."
"How to Create and Use Partial Functions in Scala"
"When using await data, the server hangs on to the server side cursor
for 300ms of inactivity before the cursor is subject to clean up. If
your write activity is low, the cursor you are following may have been
cleaned on the server. If you like to tail the oplog indefinitely,
your application will need to start a loop and remember where it last
read from the oplog so that it can continue tailing if the cursor is
lost. Here's a sample method, written in Java. Remember to sleep for a
reasonable period of time. You don't want to hit the server too often. "
"Learn how Netflix applies the Rx programming model to streams of data in finite, infinite and distributed infinite stream uses cases including a distributed system doing anomaly detection.
The presentation digs into the details of flow control and various approaches to achieve it including "reactive pull", a dynamic push/pull approach that composes backpressure into the streams."
"Thus far Rx has left backpressure solutions "an exercise for the user". It can be done via manual feedback loops and operators like throttle, sample, window, etc.
The drawback of this is that it requires someone understanding the implication of every operator and when it might be async (buffer/queue) and requires the effort to create a feedback loop and hook it up correctly. Some use cases will probably always require this type of manual effort, but it's worth exploring whether we can solve the general use cases within Rx.
Most Rx operators are synchronous in nature meaning the producing thread does not return until the work is completed. The map operator is a good example. It does computation work to transform from T -> R and nothing else.
There are some operators though that are async in nature and involve unbounded buffers. These include observeOn, zip and merge (as of 0.17.1 which means flatMap is affected). It also happens if an Observer is writing the data out to non-blocking IO (such as a Netty channel).
In all of these example, if the producer is fast, such as an in-memory Iterable, loading a file, or a firehose of events over a network, buffer-bloat (and eventually OutOfMemory) can easily occur.
After some experimentation and talking with various individuals, teams and companies about this topic, a possible solution is the use of co-routines from the producing Observable that a Subscriber can request data from in batches."
"@benjchristensen's team has a very real need for an Observable type with backpressure. As such, this type WILL exist. And it can exist in one of three ways:
We work it into this Observable type
We develop it as a separate type alongside our Observable in this library/community
Netflix creates a totally separate library/community
Different strokes for different folks within Netflix
@trxcllnt and @jhusain have need for an Observable type that has very short function call stacks and is very, very fast. This is because they need an Observable that will operate in non-JIT'ed environments on very weak hardware (That cheap smart TV you bought three years ago, for example).
... so this decision will not be met with any small amount of debate here at Netflix. I'm really hoping the larger community of GitHub comes in handy with thoughtful comments and concerns on both sides."
"There are a variety of strategies with which you can exercise flow control and backpressure in RxJava in order to alleviate the problems caused when a quickly-producing Observable meets a slow-consuming observer. This page explains some of these strategies, and also shows you how you can design your own Observables and Observable operators to respect requests for flow control."
"This summer, I built a custom dashboard called krazydash as an intern project to monitor the krazyglue app. We are already using services like Jenkins and Splunk to monitor our app, so why need another? krazydash aims to not replace any of these services but to aggregate and streamline."
"Simple and beautiful wallboards for everyone"
"Software projects are displayed by Gource as an animated tree with the root directory of the project at its centre. Directories appear as branches with files as leaves. Developers can be seen working on the tree at the times they contributed to the project.
Gource includes built-in log generation support for Git, Mercurial, Bazaar and SVN. Gource can also parse logs produced by several third party tools for CVS repositories."
"Dashing is a Sinatra based framework that lets you build beautiful dashboards."
"While the docs are fantastic for most of the transforming and combining operations, when it came to the threading operations, I struggled to understand exactly how they worked. Based on what I thought they’d do, I forged ahead and attempted to slot them into the working, single-threaded code I already had, but the results were not at all what I expected to see."
"We are missing something, and that something is a factory for the collection to create. And Scala already has a trait for that kind of factories in the Scala standard library: it is called CanBuildFrom."
"Scala allows us to easily execute a block of code asynchronously using futures from scala.concurrent. At Quantifind, we utilize Scala futures to concurrently execute hundreds of thousands of numerical calculations in parallel. However, one issue that we recently ran into is the JVM running out of memory and crashing due to a lack of available heap space. We found that the root cause was over-instantiation of futures."
"When I was young I had no sense of myself. All I was, was a product of all the fear and humiliation I suffered. Fear of my parents. The humiliation of teachers calling me “garbage can” and telling me I’d be mowing lawns for a living. And the very real terror of my fellow students. I was threatened and beaten up for the color of my skin and my size. I was skinny and clumsy, and when others would tease me I didn’t run home crying, wondering why. I knew all too well. I was there to be antagonized. In sports I was laughed at. A spaz. I was pretty good at boxing but only because the rage that filled my every waking moment made me wild and unpredictable. I fought with some strange fury. The other boys thought I was crazy.
"A basic example of using Dispatch with Scalatra on Jetty 8.x / AsyncServlet 3.0. It took me a lot of time to connect the dots how to use Dispatch asynchronously and actually process the results (not simply return them) and I could not find examples how to use Scalatra with AsyncServlet either. So here it is for anyone who could find it useful and save themselves a few –or more– hours."