README.md

KRAKEN_KEY=myKrakenKeyHere
KRAKEN_SECRET=myKrakenSecretKeyHere
INVESTMENT_AMOUNT=11.11

git clone github.com/0x13a/bitcoin-trading-dca &&cd bitcoin-trading-dca

README.org

(lispy-set-key-theme '(lispy c-digits))

(add-hook 'lispy-mode-hook#'lispyville-mode)

(with-eval-after-load 'lispyville
  (lispyville-set-key-theme
   '(operators
     c-w
     (escape insert)
     (additional-movement normal visual motion))))

(lispy-define-key lispy-mode-map "m"#'lispyville-toggle-mark-type);; or v for better consistency (I swap m and v)
(lispy-define-key lispy-mode-map "v"#'lispyville-toggle-mark-type)

;; enter visual state after `lispy-mark-symbol' with correct selection
(evil-define-key 'normal lispyville-mode-map"v" (lispyville-wrap-command lispy-mark-symbol visual));; enter lispy special after `lispy-mark-symbol' with correct selection
(evil-define-key 'normal lispyville-mode-map"v" (lispyville-wrap-command lispy-mark-symbol special))

(lispyville-enter-visual-when-marking)

(setq lispy-safe-delete t
      lispy-safe-copy t
      lispy-safe-paste t
      lispy-safe-actions-no-pull-delimiters-into-comments t)

README.md

$ minikube start --vm-driver=xhyve

$ kubectl apply -f ./faas.yml,monitoring.yml

$ kubectl apply -f ./rbac.yml

$ kubectl delete deployment/nodeinfo ; \
  kubectl delete service/nodeinfo ; \
  kubectl run --labels="faas_function=nodeinfo" nodeinfo --port 8080 --image functions/nodeinfo:latest ; \
  kubectl expose deployment/nodeinfo

$ kubectl get service gateway
NAME      CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
gateway   10.106.11.234   <nodes>       8080:31112/TCP   1h

$ minikube ssh 'curl -s 10.106.11.234:8080/system/functions'

[{"name":"nodeinfo","image":"functions/nodeinfo:latest","invocationCount":0,"replicas":1}]

$ curl -s http://$(minikube ip):31112/system/functions

[{"name":"nodeinfo","image":"functions/nodeinfo:latest","invocationCount":0,"replicas":1}]

curl -s --data "" http://$(minikube ip):31112/function/nodeinfo
Hostname: nodeinfo-2186484981-lcm0m

Platform: linux
Arch: x64
CPU count: 2
Uptime: 19960

$ kubectl scale deployment/nodeinfo --replicas=2

ip=$(minikube ip); while [ true ] ; do curl $ip:31112/function/nodeinfo -d "" ; done

$ open http://$(minikube ip):31119/

rate(gateway_function_invocation_total[20s])

$ open http://$(minikube ip):31112/

"Something's a little bit off here." That's what I predict your first thought to be upon seeing my cubicle for the first time. There's no screen or mouse in sight. Instead there's a guy hammering away on a keyboard, staring at seemingly nothing.

It's only me, and my colleagues can assure you that I'm mostly harmless. I'm a software developer working at Vincit offices in Tampere. I'm also blind. In this blog post I'm going to shed some light on the way I work.

Are you blind as in actually blind?

Correct. I can perceive sunlight and some other really bright lights but that's about it. In essence, nothing that would be useful for me at work.

What are you doing there, then?

The same as almost everyone else, that is: making software and bantering with my colleagues whenever the time permits. I have worked in full stack web projects with a focus on the backend. I have also taken up the role of a general accessibility consultant – or police; depends on how you look at it.

How do you use the computer?

The computer I use is a perfectly normal laptop running Windows 10. It's in the software where the "magic happens". I use a program called a screen reader to access the computer. A screen reader intercepts what's happening on the screen and presents that information via braille (through a separate braille display) or synthetic speech. And it's not the kind of synthetic speech you hear in today's smart assistants. I use a robotic-sounding voice which speaks at around 450 words per minute. For comparison, English is commonly spoken at around 120-150 words per minute. There's one additional quirk in my setup: Since I need to read both Finnish and English regularly I'm reading English with a Finnish speech synthesizer. Back in the old days screen readers weren't smart enough to switch between languages automatically, so this was what I got used to. Here's a sample of this paragraph being read as I would read it:

And here's the same text spoken by an English speech synthesizer:

A mouse is naturally not very useful to me so I work exclusively at the keyboard. The commands I use should be familiar to anyone reading this post: Arrow keys and the tab key move you around inside a window, alt+tab changes between windows etc. Screen readers also have a whole lot of shortcuts of their own, such as reading various parts of the active window or turning some of their features on or off.

It's when reading web pages and other formatted documents that things get a little interesting. You see, a screen reader presents its information in chunks. That chunk is most often a line but it may also be a word, a character or any other arbitrary piece of text. For example, if I press the down arrow key on a web page I hear the next line of the page. This type of reading means that I can't just scan the contents of my screen the same way a sighted person would do with their eyes. Instead, I have to read through everything chunk by chunk, or skip over those chunks I don't care about.

Speech or braille alone can't paint an accurate representation of how a window is laid out visually. All the information is presented to me in a linear fashion. If you copy a web page and paste it into notepad you get a rough idea of how web pages look to me. It's just a bunch of lines stacked on top of another with most of the formatting stripped out. However, a screen reader can pick up on the semantics used in the HTML of the web page, so that links, headings, form fields etc. are announced to me correctly. That's right: I don't know that a check box is a check box if it's only styled to look like one. However, more on that later; I'll be devoting an entire post to this subject. Just remember that the example I just gave is a crime against humanity.

I spend a good deal of my time working at the command line. In fact I rarely use any other graphical applications than a web browser and an editor. I've found that it's often much quicker to do the task at hand on the command line than to use an interface which was primarily designed with mouse users in mind.

So, given my love of the command line, why am I sticking with Windows, the operating system not known for its elegant command line tools? The answer is simple: Windows is the most accessible operating system there is. NVDA, my screen reader of choice is open source and maintained more actively than any other screen reader out there. If I had the choice I would use Mac OS since in my opinion it strikes a neat balance between usability and functionality. Unfortunately VoiceOver, the screen reader built in to Mac OS, suffers from long release cycles and general neglect, and its navigation models aren't really compatible with my particular way of working. There's also a screen reader for the Gnome desktop and, while excellently maintained for such a minor user base, there are still rough edges that make it unsuitable for my daily use. So, Windows it is. I've been compensating for Windows' inherent deficiencies by living inside Git Bash which comes with an excellent set of GNU and other command line utilities out of the box.

How can you code?

It took me quite a long time to figure out why this question was such a big deal for so many people. Remember what I said earlier about reading text line by line? That's how I read code. I do skip over the lines that aren't useful to me, or maybe listen only halfway through them just for context, but whenever I actually need to know what's going on I have to read everything as if I were reading a novel. Naturally I can't just read through a huge codebase like that. In those cases I have to abstract some parts of the code in my mind: this component takes x as its input and returns y, never mind what it actually does.

This type of reading makes me do some coding tasks a little bit differently than my sighted colleagues. For example, when doing a code review I prefer to look at the raw diff output whenever I can. Side-by-side diffs are not useful to me, in fact they are a distraction if anything. The + and - signs are also a far better indicator of modified lines than background colours, not because I couldn't get the names of those colours, but because "plus" takes far less time to say than some convoluted shade of red that is used for highlighting an added line. (I am looking at you, Gerrit.)

You might think that indentation and other code formatting would be totally irrelevant to me since those are primarily visual concerns. This is not true: proper indentation helps me just as much as it does a sighted programmer. Whenever I'm reading code in braille (which, by the way, is a lot more efficient than with speech) it gives me a good visual clue of where I am, just like it does for a sighted programmer. I also get verbal announcements whenever I enter an indented or unindented block of text. This information helps me to paint a map of the code in my head. In fact Python was the first real programming language I picked up (Php doesn't count) and its forced indentation never posed a problem for me. I'm a strong advocate of a clean and consistent coding style for a number of reasons, but mostly because not having one makes my life much more difficult

Which editor do you prefer?

Spoiler alert: The answer to this question doesn't start with either V or E. (Granted, I do use Vim for crafting git commit messages and other quick notes on the command line. I consider myself neutral on this particular minefield.) A year ago my answer would have been, of all things, Notepad++. It's a lightweight, well-made text editor that gets the job done. However, a year ago I hadn't worked in a large-scale Java project. When that eventually happened it was time to pick between Notepad++ and my sanity. I ended up clinging to the latter (as long as I can, anyway) and ditching Notepad++ in favour of IntelliJ IDEA. It has been my editor of choice ever since. I have a deeply-rooted aversion towards IDEs since most of them are either inaccessible or inefficient to work with solely on the keyboard. Chances are that I would have switched to using an IDE a lot sooner if I was sighted.

But why Notepad++, you might ask. There are more advanced lightweight editors out there like Sublime text or Atom. The answer is simple: neither of them is accessible to screen readers. Text-mode editors like Vim aren't an option either, since the screen reader I use has some problems in its support of console applications that prevent those editors from being used for anything longer than a commit message. Sadly, accessibility is the one thing that has the last word on the tools I use. If it's not workable enough that I can use it efficiently, it's out of the question.

Do you ever work with frontend code?

You would think that frontend development was so inherently visual that it would be no place for a blind developer, and for the most part that is true. You won't find me doing a basic Proof-of-Concept on my own, since those projects tend to be mostly about getting the looks right and adding the real functionality later.

However, I've had my fair share of Angular and React work too. How's that? Many web apps of today have a lot going on under the hood in the browser. For example, I once worked a couple of weeks adding internationalization support to a somewhat complex Angular app. I didn't need to do any visual changes at all.

I've found that libraries like Bootstrap are a godsend for people like me. Because of the grid system I can lay out a rough version of the user interface on my own. Despite this all the interface-related changes I'm doing are going through a pair of eyes before shipping to the customer. So, to sum up: I can do frontend development up to a point, at least while not touching the presentation layer too much.

How about all the things you didn't mention?

There are certainly a lot of things I had to leave out of this blog post. As promised I'll be devoting a post to the art of making web pages more accessible, since the lack of proper semantics is one of my pet peeves. However, there's a good chance I won't leave it at that. Stay tuned!

A team of 30 students from Germany won the SpaceX Hyperloop Pod competition on Sunday, with their prototype pod reaching a speed of 324 kilometers per hour (201 miles per hour).

The team, named WARR Hyperloop, was one of three finalists to participate in Sunday’s competition, held at SpaceX’s headquarters in Hawthorne, CA. The teams were tasked with developing a prototype pod to travel down a 1.2-kilometer (0.75-mile) tube, as part of SpaceX CEO Elon Musk’s vision for a Hyperloop high-speed transport system. The pod that reached the highest maximum speed would be crowned the winner.

WARR’s prototype, a lightweight, carbon-fiber pod, comfortably beat submissions from the two other teams, whose members hailed from Switzerland, Canada and the US. The 176-pound WARR pod is powered by a 50kW electric motor and features four pneumatic friction brakes that allow the pod to come to a standstill within five seconds, according to the team’s website.

The team from Munich Technical University also won the prize for fastest pod at the first Hyperloop Pod competition in January, when its prototype reached a speed of 58 mph. Musk congratulated WARR in a tweet on Sunday, adding in a subsequent tweet that it may be possible to reach “supersonic” speeds in the test Hyperloop tube.

In the West, plot is commonly thought to revolve around conflict: a confrontation between two or more elements, in which one ultimately dominates the other. The standard three- and five-act plot structures–which permeate Western media–have conflict written into their very foundations. A “problem” appears near the end of the first act; and, in the second act, the conflict generated by this problem takes center stage. Conflict is used to create reader involvement even by many post-modern writers, whose work otherwise defies traditional structure.

The necessity of conflict is preached as a kind of dogma by contemporary writers’ workshops and Internet “guides” to writing. A plot without conflict is considered dull; some even go so far as to call it impossible. This has influenced not only fiction, but writing in general–arguably even philosophy. Yet, is there any truth to this belief? Does plot necessarily hinge on conflict? No. Such claims are a product of the West’s insularity. For countless centuries, Chinese and Japanese writers have used a plot structure that does not have conflict “built in”, so to speak. Rather, it relies on exposition and contrast to generate interest. This structure is known as kishōtenketsu.

Kishōtenketsu contains four acts: introduction, development, twist and reconciliation. The basics of the story–characters, setting, etc.–are established in the first act and developed in the second. No major changes occur until the third act, in which a new, often surprising element is introduced. The third act is the core of the plot, and it may be thought of as a kind of structural non sequitur. The fourth act draws a conclusion from the contrast between the first two “straight” acts and the disconnected third, thereby reconciling them into a coherent whole. Kishōtenketsu is probably best known to Westerners as the structure of Japanese yonkoma (four-panel) manga; and, with this in mind, our artist has kindly provided a simple comic to illustrate the concept.

Each panel represents one of the four acts. The resulting plot–and it is a plot–contains no conflict. No problem impedes the protagonist; nothing is pitted against anything else. Despite this, the twist in panel three imparts a dynamism–a chaos, perhaps–that keeps the comic from depicting merely a series of events. Panel four reinstates order by showing us how the first two panels connect to the third, which allows for a satisfactory ending without the need for a quasi-gladiatorial victory. It could be said that the last panel unifies the first three. The Western structure, on the other hand, is a face-off–involving character, theme, setting–in which one element must prevail over another. Our artist refitted the above comic into the three-act structure to show this difference.

The first panel gives the reader a “default position” with which to compare later events; and the second panel depicts a conflict-generating problem with the vending machine. The third panel represents the climax of the story: the dramatic high point in which the heroine's second attempt "defeats" the machine and allows the can to drop. The story concludes by depicting the aftermath, wherein we find that something from the first act has changed as a result of the climax. In this case, our heroine sans beverage has become a heroine avec beverage.

What this shows is that the three-act plot, unlike kishōtenketsu, is fundamentally confrontational. It necessarily involves one thing winning out over another, even in a minor case like the one above. This conclusion has wide-ranging implications, since both formats are applied not just to narratives, but to all types of writing. Both may be found under the hood of everything from essays and arguments to paragraphs and single sentences. As an example, the reader might re-examine the first two paragraphs of this article, in which a “default position” is set up and then interrupted by a “problem” (namely, the existence of kishōtenketsu). The following paragraphs deal with the conflict between the two formats. This paragraph, which escalates that conflict by explaining the culture-wide influence of each system, is the beginning of the climax.

As this writer is already making self-referential, meta-textual remarks, it is only appropriate that the article’s climax take us into the realm of post-modern philosophy. It is a worldview obsessed with narrative and, perhaps unconsciously, with the central thesis of the three-act structure. Jacques Derrida, probably the best known post-modern philosopher, infamously declared that all of reality was a text–a series of narratives that could only be understood by appealing to other narratives, ad infinitum. What kinds of narratives, though? Perhaps a benign, kishōtenketsu-esque play between disconnection and reconnection, chaos and order? No; for Derrida, the only narrative was one of violence. As a Nietzschean, he believed that reality consisted, invariably, of one thing dominating and imposing on another, in a selfish exercise of its will to power. The “worst violence”, he thought, was when something was completely silenced and absorbed by another, its difference erased. Apparently, Derrida was uncontent with the three-act structure’s nearly complete control over Western writing: he had to project it onto the entire world. Eurocentrism has rarely had a more shining moment.

Kishōtenketsu contains no such violence. The events of the first, second and third acts need not harm one another. They can stand separately, with Derrida’s beloved difference intact. Although the fourth act unifies the work, by no means must it do violence to the first three acts; rather, it is free merely to draw a conclusion from their juxtaposition, as Derrida does when he interprets one narrative through the lens of another. A world understood from the kishōtenketsu perspective need never contain the worst violence that Derrida fears, which would make his call for deconstruction–the prevention of silence through the annihiliation of structure–unnecessary. Is it possible that deconstruction could never have been conceived in a world governed by kishōtenketsu, rather than by the three-act plot? Is the three-act structure one of the elements behind the very worldview that calls for its deconstruction? Can the Western narrative of the will to power remain coherent in the face of a rival narrative from the East? This writer would prefer to ask than to answer these questions.

Now, dear readers, comes the aftermath. The dust left over from the climax is settling. Kishōtenketsu has been shown to generate plot without conflict, which reveals as insular nonsense the West’s belief that they are inseparable. The repercussions of this extend to all writing; and, if this writer's conclusion is to be believed, to philosophy itself. Despite this, it should be noted that many of history’s greatest works have been built on the three- and five-act structures. By no means should they be discarded. Rather, they should be viewed as tools for telling certain types of stories. At the same time, this writer would like to end by calling for a renewed look at kishōtenketsu in the West. It offers writers the opportunity to explore plots with minimal or no conflict. Perhaps it could even change our worldview.

Still Eating Oranges

“Silicon Valley looks at inefficiencies in the world, and they aim to disrupt the food space,” said Erik Oberholtzer, a founder and the chief executive of Tender Greens, a quick-service chain based in Los Angeles that is using data to guide its East Coast expansion. “I mean that in a good way.”

In the old days, restaurateurs used ledgers to track sales, and scribbled notes about their customers’ preferences or idiosyncrasies. Then along came point-of-sale software and reservation services that provided more sophisticated records and analysis, but created a tech tower of Babel, with most systems speaking their own dialect.

Avero, a Manhattan-based company founded in 1999, defined the next generation of analytics: It translated data into a common language, added external data and generated an easy-access overview of inventory, food costs and sales, accounting, scheduling and customer behavior. “Not 40 systems with 40 passwords,” said Avero’s founder, Damian Mogavero.

Newer companies now aspire to eliminate the need for translation, to create an analytics program that integrates all aspects of a restaurant’s operations into one system, with one password, in real time with mobile access, said Shu Chowdhury, the chief executive of a start-up called Salido, based in SoHo. One of its initial investors is the chef Tom Colicchio, who is using it as he revamps and expands his chain of ‘Wichcraft sandwich shops.

These new tools make a paradoxical promise: that they can take restaurants back to the good old days, before the business grew so big.

“The goal,” Mr. Oberholtzer said, “is to leverage the technology to do what we would do if we had one little restaurant and we were there all the time and knew every customer by name.”

Mr. Oberholtzer and his two partners opened the first of two dozen cafeteria-style restaurants in Culver City, Calif., in 2006, and plan to open an equal number in the Northeast by 2020. Every new Tender Greens will rely on what he calls “a whole rebuild of technology,” because the 11-year-old system it uses is about as up-to-date as a beeper.

He has decided on a combination of three systems that “play well with others,” he said, so there’s no communications problem: Brink POS software, a point-of-sale system that Mr. Oberholtzer says “is robust enough to handle volume and simple enough for our teams to use easily,” an essential combination for an expanding company; Olo, to coordinate online ordering and delivery; and the Punchh mobile app, which logs each customer’s name, email address and purchase history.

“It gives us ways to recognize people who’ve been in regularly, or haven’t been in for a while or have specific preferences,” Mr. Oberholtzer said.

A regular diner who always orders the niçoise salad will get a message on the app about the halibut special. A diner who always orders vegetarian options will not get the message about the summer hog roast. “We want to accommodate everyone’s needs,” Mr. Oberholtzer said, “sometimes before they even mention them.”

In Chicago, at the Michelin-starred Oriole, where 28 diners sit down each night to a $190 tasting menu, the owners, Noah and Cara Sandoval, rely on data from the Upserve system to identify their top 100 guests in terms of numbers of visits and amount spent, but that’s just the start. The system also creates a profile with every first-time reservation.

“You can’t know that someone’s going to become a regular, so you don’t necessarily keep track of those people,” Ms. Sandoval said. “But the system does.” It also tracks the top 100’s dining companions when they split the check. Upserve sends a list of credit card numbers, dates of visits and items bought; the restaurant matches each number to a name, and a search on Google, Facebook and LinkedIn provides a face to go with it.

“We’re sure to recognize them” the next time they come in, so the staff can welcome them back by name, Ms. Sandoval said. “It surprises people, in a nice way, when they didn’t make the reservation themselves.”

Even the type of credit card contributes to the dossier. If a customer pays with an airline card, a server might mention travel. If a customer is a sports fan, he will most likely get a server who is as well.

The food gets similar scrutiny. Upserve offers a “magic quadrant” feature that divides dishes into four categories— “greatest hits,” “underperformers,” “one-hit wonders” that are popular with first-timers but not with repeat visitors, and “hidden gems,” which regulars like and first-timers don’t — to help the Sandovals understand which are popular, and which prompt diners to return.

Customers who find the mining of personal data invasive can opt out, up to a point, but it requires effort: To avoid detection, they have to pay cash and not make reservations. Those who participate actively in the process get more information in return.

In June 2015, the online reservation service OpenTable, which represents 43,000 restaurants worldwide, started to provide customized recommendations, just as Netflix and Amazon suggest programs or products based on a customer’s history.

If users sign up for the company’s app and allow OpenTable access to their GPS, they receive recommendations for restaurants in the United States and several foreign countries, said Scott Jampol, the company’s senior vice president for marketing.

And if data can help a customer find a restaurant, it can also help a restaurant find its customers. To pinpoint potential locations in the Northeast that best reach what Mr. Oberholtzer calls Tender Greens’s “psychographic” — the college-educated diner who cares about health and locally produced food — he starts with data from a customer analytics firm that specializes in site selection.

He refines that list with Google searches like “plant-forward lifestyle,” he said, and looks at where delivery systems like Uber and DoorDash do a lot of business.

“You overlay and look for redundancy,” he said, “and that begins to tell the story of where you want to be.”

But successful growth makes it hard to keep a sharp eye on operations. Charlee Williamson has been with the New Orleans-based Ralph Brennan Restaurant Group for 24 years, and keeps track of six managers and 78 servers at the Jazz Kitchen, thousands of miles away at Disneyland in California. She relies on the Server Scorecard, a feature offered by Avero.

The scorecard ranks servers on multiple criteria, which makes it easier for Ms. Williamson to identify the right waiter, for example, for a large party with children. She might not pick the server who sells the most. The more appropriate match could be a server who ranks higher in tip percentage than in sales, thanks to grateful families who tend to order less alcohol.

The message to restaurateurs is simple: Ignore data at your peril, said Mr. Mogavero, the author of a recent book, “The Underground Culinary Tour,” about how data has transformed the restaurant industry.

Start-ups aspire to create even more streamlined software, but it isn’t easy. “We’re making a moon shot here,” said Mr. Chowdhury of Salido, which originally set an August deadline for “a fully operational stack” of features but is only about three-quarters of the way there. The company has extended its deadline to early 2018, as development work continues with 64 existing clients.

The basic point-of-sale part of the program is already in use in New York at Made Nice, the new fast-casual restaurant from the chef Daniel Humm and Will Guidara, owners of Eleven Madison Park and the NoMad, and at Jean-George Vongerichten’s ABC Kitchen.

Still, some early adopters approach the new systems warily. Mr. Guidara, who also uses Avero at Eleven Madison Park, thinks technology is great for a fast-casual operation that emphasizes volume and delivery, and for the business side at a fine-dining operation. It has no place, he said, when it comes to service at Eleven Madison Park or the NoMad, where he and Mr. Humm rely on traditional methods of high-end hospitality: expertise, eye contact and a hair-trigger response to a diner’s every need.

“When I worked as a controller, in accounting capacities, we used it quite often,” Mr. Guidara said. “But from an experiential, guest-facing point of view, we don’t use it. That’s never been how we approach things.”

The chef David Kinch owns Manresa in Northern California, which won its third Michelin star in 2016. His reservationist does a Google search every guest to ferret out basic information like occupation or interests, and then he relies on a highly trained staff, including a concierge and two master sommeliers, to work the room and ensure everyone is happy.

“I’m pushed constantly about these new systems,” Mr. Kinch said. “People say it’s all about the guest? I think that couldn’t be further from the truth. I place a tremendous value on direct eye contact and a genuine smile.”

At Oriole, the Sandovals have left sake on the menu despite data showing that it doesn’t sell well. “We go by our gut,” Ms. Sandoval said. “It pairs well with a lot of the courses, it’s very versatile, and it speaks to how we’re willing not to go the traditional route.”

The sheer glut of new restaurant data systems can be overwhelming, even to those who embrace them.

“At least once a week, I get something about a new start-up with a new gadget that’s going to make our lives so much better,” said Sisha Ortuzar, Mr. Colicchio’s partner at ‘Wichcraft. “They’re distractions. We just want to get back to making sandwiches.”

Follow NYT Food on Facebook, Instagram, Twitter and Pinterest. Get regular updates from NYT Cooking, with recipe suggestions, cooking tips and shopping advice.

By Dmitry Mukhin, CTO at Uploadcare.

Uploadcare is a file infrastructure as a service solution. We offer building blocks for handling files that provide simple controls for managing complex technologies. These controls include our widget, Upload API, REST API, and CDN API. All together these APIs handle 350M requests per day.

With only a few lines of code you get the ability to upload, store, process, cache, and deliver files. We support uploads from Dropbox, Facebook, and many other external sources. We also allow our users to upload files directly to their storage.

Yes, you can handle files on your own and you can get the basic system up and running pretty fast. What about storage? Uptime? A clear and friendly UI? Fast delivery to remote regions? For most of the use cases we analyzed, there is no sense in investing in developing your own file infrastructure.

Setting up Uploadcare is quick and solves many of the issues users traditionally experience when handling both large files and batches of smaller ones. Additionally you no longer need to test your system in every browser and maintain the infrastructure.

Uploadcare has built an infinitely scalable infrastructure by leveraging AWS. Building on top of AWS allows us to process 350M daily requests for file uploads, manipulations, and deliveries. When we started in 2011 the only cloud alternative to AWS was Google App Engine which was a no-go for a rather complex solution we wanted to build. We also didn’t want to buy any hardware or use co-locations.

Our stack handles receiving files, communicating with external file sources, managing file storage, managing user and file data, processing files, file caching and delivery, and managing user interface dashboards.

From the beginning we built Uploadcare with a microservice based architecture.

These are the challenges we faced in each layer of our stack.

Backend

At its core, Uploadcare runs on Python. The Europython 2011 conference in Florence really inspired us, coupled with the fact that it was general enough to solve all of our challenges informed this decision. Additionally we had prior experience working in Python.

We chose to build the main application with Django because of its feature completeness and large footprint within the Python ecosystem.

All the communications within our ecosystem occur via several HTTP APIs, Redis, Amazon S3, and Amazon DynamoDB. We decided on this architecture so that our our system could be scalable in terms of storage and database throughput. This way we only need Django running on top of our database cluster. We use PostgreSQL as our database because it is considered an industry standard when it comes to clustering and scaling.

Uploads, External sources

Uploadcare lets users upload files using our widget. We support multiple upload sources including APIs that only require URLs.

Uploaded files are received by the Django app where the majority of the the heavy lifting is done by Celery. It’s great for handling queues and it’s got a great community with tons of tutorials and examples to leverage. Celery handles uploading large files, retrieving files from different upload sources, storing files, and pushes files to Amazon S3. All the communications with external sources are handled by separate Amazon EC2 instances where load balancing is handled by AWS Elastic Load Balancer. The EC2 instances responsible for uploads are kept separate from the rest of the application.

The only two issues we have experienced with AWS are inaccurate reports from the AWS status page and failing to plan ahead when reserving resources to reduce costs and inefficiencies.

File storage, User and file data

We use Amazon S3 for storage. The EC2 upload instances, REST API, and processing layer all communicate with S3 directly. S3 gives us the ability to store customer files forever if they desire it.

File and user data are managed with a heavily customized Django REST framework. At first we used the out of the box Django REST framework as it helped us to rapidly deploy features. However, as our vision of how a REST API should work evolved we implemented customizations to fit our use cases. The footprint of our custom additions has grown large enough that updating the framework is a pain point. We're looking to modify this part of our stack to avoid adding further customizations that would compound this problem.

We use the micro framework Flask to handle sensitive data and OAuth communications. It is lightweight and efficient and doesn’t include any features that we don’t need such as queues, an ORM layer, or caches.

We explore this topic in more detail in an article on cloud-security on our blog explaining how Uploadcare gets content from social media and how we treat end user privacy.

Processing

The 350M API requests we handle daily include many processing tasks such as image enhancements, resizing, filtering, face recognition, and GIF to video conversions.

Our file processing requirements necessitate using asynchronous frameworks for IO-bound tasks. Tornado is the one we currently use and aiohttp is the one we intend to implement in production in the near future Both tools support handling huge amounts of requests but aiohttp is preferable as it uses asyncio which is Python-native.

Our real-time image processing is a CPU-bound task. Since Python is in the heart of our service, we initially used PIL followed by Pillow. We kind of still do. When we figured resizing was the most taxing processing operation, Alex, our engineer, created the fork named Pillow-SIMD and implemented a good number of optimizations into it to make it 15 times faster than ImageMagick. Thanks to the optimizations, Uploadcare now needs six times fewer servers to process images. Here, by servers I also mean separate EC2 instances handling processing and the first layer of caching. The processing instances are also paired with ELB which helps ingest files to the CDN.

Caching, Delivery

There are three layers of caching which help improve the overall performance:

• Caching in the processing engine so that same operations are not run many times
• Caching inside CDN-Shield, for CDN edges not to hammer origins and cache things more effectively
• Cache on the CDN edges as the frontier closest to consumer devices

For delivery, files are then pushed to Akamai CDN with the help of nginx and AWS Elastic Load Balancer. We also use Amazon CloudFront but due to the lack of coverage, we moved to Akamai as default CDN. Also, Akamai has many cool features, for instance, it allows us to automatically adjust imagea formats to user browsers.

It's also worth adding that our file receive/deliver ratio is strongly biased toward delivery.

Front-end

Simple controls over complex technologies, as we put it, wouldn't be possible without neat UIs for our user areas including start page, dashboard, settings, and docs.

Initially, there was Django. Back in 2011, considering our Python-centric approach, that was the best choice. Later, we realized we needed to iterate on our website more quickly. And this led us to detaching Django from our front end. That was when we decided to build an SPA.

Building SPA for our front page, docs, and other site sections from scratch is an ongoing process. It's done with Node.js which is asynchronous and provides isomorphic rendering. In order to communicate with our older Django-based front end, it uses JSON API through nginx. And that's a rule of thumb we stick to: once separated, the communications between our front and back end will still be carried out via JSON API.

For building user interfaces, we're currently using React as it provided the fastest rendering back when we were building our toolkit. And it’s not just it: React has a great community which helps you code less and build more. It’s worth mentioning Uploadcare is not a front-end-focused SPA: we aren’t running at high levels of complexity. If it were, we’d go with Ember.

However, there's a chance we will shift to the faster Preact, with its motto of using as little code as possible, and because it makes more use of browser APIs.

On the client, we work with data using Redux.js and do routing via React Router. The latter is a great example of the awesome React community.

One of our future tasks for our front end is to configure our Webpack bundler to split up the code for different site sections. Currently, when you load a site page, you also get the code for all the other pages. Webpack is also a code-less-build-more tool with vast amounts of community examples to use as starter kits. We were thinking of using Browserify or Rollup, but they did not have a runtime and either worked slower than Webpack or required us to do way more coding to provide similar functionality. Plus, async chunks are easier to handle with Webpack.

As for the static site pages, many of them are Markdown-formatted files sitting in a GitHub repo. Overall, we’re using a GitHub Pull Request Model for deployment. The files from a repo then go through jinja2-inspired nunjucks followed by markdown-it and posthtml. Our docs are built this way, for instance.

For styles, we use PostCSS along with its plugins such as cssnano which minifies all the code.

As you can tell, we like the idea of post-processors. posthtml, for instance is a parser and a stringifier providing an Abstract Syntax Tree which is easy to work with.

All that allows us to provide a great user experience and quickly implement changes where they are needed with as little code as possible.

Deployment

As I mentioned above, we use the GitHub Pull Request Model. Certain parts of the process are automatic while others require manual intervention. We use the following steps:

• We create a branch in a repo with one of our features
• Commits are made to the branch. That’s followed by automatic tests inTeamCity
• If tests pass, a PR is created followed by both auto tests and code review by the dev team
• If tests pass/review ok, we merge changes to the staging branch which is then automatically deployed via TeamCity and Chef
• When deployed, we run integration tests via TeamCity
• If everything is green, we merge changes to the production branch and run one more battery of tests automatically via TeamCity
• If tests pass and we ensure it’s not some Friday night, we deploy to production. Chef scripts here are run by devops.

We get notified about deployment status via a Slack channel. Regarding reports, we get a lot of input from our monitoring stack which includes Rollbar for reporting errors and exceptions, LogDNA for logging, Pingdom for testing our services externally, Amazon CloudWatch for monitoring AWS stats, and Datadog for consolidating reports and monitoring health status of our servers and services.

Team administration, tasks, communication

Along with Slack, there's also G Suite for emails, Trello for planning, HelpScout and Intercom for customer success communications and client relations, and more.

Vision

Since we provide the complete set of building blocks for handling files, we encourage everyone out there to use similar building blocks for different parts of their products. Our stack is a great example of that— it's a collection of pre-built components. And we can always go on and add more to the list. For instance, we're using Segment to send data for analyses, which, in turn, are carried out by Kissmetrics,Keen IO, Intercom, and others. We’re using Stripe for processing payments.

We practice what we preach: focus on what you want to create and let those building blocks handle the specific tasks they were made for.

A group of researchers from the University of Lausanne in Switzerland and the University of Edinburgh in the UK suggests that a different game, called the “iterated Snowdrift game” (ISD), may more realistically reflect social situations that humans face, compared with the IPD. In experimental tests, the proportion of cooperative acts in the ISD game (48%) was significantly higher than those in the IPD (29%).

The cause for this difference is due to the higher risks of being exploited in the IPD compared with the ISD, where the risk of being exploited by someone who doesn’t cooperate when you do is lower.

“In principle, natural selection predicts individuals to behave selfishly,” Rolf Kümmerli, co-author of the study, told PhysOrg.com. “However, we observe cooperation in humans and other organisms, where cooperation is costly for the actor but benefits another individual. The question is why does natural selection favor such cooperation? One solution to this problem is given by the ‘Snowdrift’ game (but not by the PD), where individuals gain direct benefits from their cooperative acts.”

The situation of the Snowdrift game involves two drivers who are trapped on opposite sides of a snowdrift. Each has the option of staying in the car or shoveling snow to clear a path. Letting the opponent do all the work is the best option (with a pay-off of 300 used in this study), but being exploited by shoveling while the opponent sits in the car still results in a pay-off of 100. (The other two possibilities, both shoveling and both sitting, have pay-offs of 200 and 0, respectively.)

Compare this with the Prisoner’s Dilemma. For a quick synopsis, two prisoners being questioned each have the choice to either defend the other’s innocence or betray the other’s guilt. As in the Snowdrift game, the best option is to betray your opponent while he defends you (pay-off of 400), and next for both of you to defend each other (pay-off of 300). Also, as in the Snowdrift game, both of you betraying results in a pay-off of 0.

However, the significant difference is in the greater risk in the Prisoner’s Dilemma when you cooperate while your opponent defects: while shoveling snow always helps you out, even when the opponent sits (100 pay-off), defending an opponent who betrays you results in the worst outcome for you—a pay-off of -100. In the study, participants cooperated more in the ISD because they could always obtain individual benefits by cooperating, while the costs of cooperating were shared between cooperators.

The researchers noticed other interesting trends in the study, which involved 96 participants (38 female and 58 male) divided into 16 groups and arranged in 48 pairs, not knowing their partner’s identity or gender. Each pair repeated (“iterated”) both games 12 times, though were initially told the number of repetitions was randomly determined. The researchers created global competition by revealing that the players with the four highest pay-offs would receive monetary awards.

Players who employed “Tit-for-Tat” and “Pavlovian” strategies—known to increase pay-offs in the IPD—had better pay-offs in both games than players who did not use these strategies. Further, the researchers found that female participants were twice as likely to use one of these strategies as male participants in the ISD (but not the IPD), resulting in both greater cooperation in female-female pairs compared with male-male pairs, as well as greater pay-offs for individual females. Interestingly, these results contrast with the theory of social sciences, suggesting that there is no simple rule on how males and females behave in different social dilemmas.

“The most significant result is that humans adapt the degree of cooperation according to the social context (ISD or IPD) and the behavior and gender of their partner,” Kümmerli said.

Besides offering a potential explanation for the high levels of cooperation among humans, the ISD may also have more real-life associations than the IPD. For example, as the researchers point out, two scientists collaborating on a report would benefit if the other worked harder. But when your collaborator doesn’t do any work, it’s probably better for you to do all the work yourself. You’ll still end up with a completed project, rather than life in prison.

“Many natural situations of cooperation are much more similar to the SD than to the PD,” Kümmerli said. “For that reason, I think that the SD can provide more indications why cooperation is favored by natural selection than the PD. However, the PD is still a useful tool for mathematical models and to demonstrate differences in cooperation between two groups and in treatment of the gender differences in our study.”

Citation: Kümmerli, Rolf, Colliard, Caroline, Fiechter, Nicolas, Petitpierre, Blaise, Russier, Flavien, and Keller, Laurent. “Human cooperation in social dilemmas: comparing the Snowdrift game with the Prisoner’s Dilemma.” Proc. R. Soc. B, doi:10.1098/rspb.2007.0793.

Copyright 2007 PhysOrg.com.
All rights reserved. This material may not be published, broadcast, rewritten or redistributed in whole or part without the express written permission of PhysOrg.com.

Julia is closest to Dylan in many regards. It uses a somewhat mainstream syntax rather than s-expressions. Unlike Dylan, you can nevertheless write ‘full’ macros, since macro definitions are implemented in Julia, not some template language, and backquote/quasiquote is integrated with the Julia syntax. Julia is a Lisp-1 (like Scheme or Dylan) rather than a Lisp-2 (like Common Lisp or ISLISP), which makes it necessary to add macro hygiene features. Fortunately, this does not mean you have to deal with the rather painful syntax-case construct of some Scheme dialects, but you can still use far simpler backquote/quasiquote constructions, just with macro hygiene taken care of by default. Julia also allows you to selectively break hygiene. Although I usually strongly prefer the simplicity of Common Lisp’s non-hygienic macro system, the fact that Julia is a Lisp-1 turns macro hygiene into a real problem, so I guess this is a reasonable design.

Julia provides object-oriented programming from the ground up, similar to Dylan. It centers on generic functions rather than classes, where methods are defined outside classes and allow for multiple dispatch, just like in Dylan and Common Lisp. Like Dylan, and unlike Common Lisp, it does not distinguish between functions and generic functions: All functions can have methods, you do not have to make up your mind whether you want methods or plain functions. Unlike in Common Lisp, there are no method combinations, no before/after/around methods, and call-next-method is not directly supported, but has to be done manually. This is probably to simplify method dispatch, maybe to have some performance advantages, though I find it hard to imagine that adding method combinations would make things substantially worse.

You still need a class hierarchy to drive method dispatch. Unlike in Common Lisp, there is no multiple inheritance, only single inheritance. In fact, there is actually no real inheritance, because in Julia, only leaf classes of the class hierarchy are allowed to define slots/fields. All superclasses are required to be “abstract,” without any slot definitions. Also, Julia classes cannot be redefined at runtime, so in fact Julia classes are much closer to Common Lisp’s structured types rather than classes.

Julia’s execution model is based on dynamic compilation. As a user, you don’t have to compile your code at all, source code is just compiled on the fly (similar as in Clozure Common Lisp). Julia inlines functions on the fly, including generic functions, and can de-optimize when function definitions change at runtime. This is more flexible than in Common Lisp, where inlined functions can get out of sync with their potentially changed definitions. Also, while the Common Lisp specification does not say anything with regard to being able to inline generic functions or not, there are aspects in the CLOS MOP specification that prevent generic functions from being inlined, at least for user-defined extensions of generic functions. Julia definitely seems more “modern” here.

In Julia, there is no distinction between variable binding and variable assignment. If you assign to a variable that has not been used before in the same lexical environment, it is silently introduced. In Common Lisp/Scheme/Dylan, there is a distinction between ‘let forms that introduce variable bindings, and assignments (setq/setf/set!) that perform assignments. I’m highly skeptical of Julia’s design here, because this potentially leads to bugs that are hard to find: A simple typo in your source code just may go unnoticed.

In Julia, all variables are lexically scoped (except for some seemingly quirky scoping semantics for global variables, see below). There are no special / dynamically scoped variables in Julia, which is a major omission in my book. Some academics don’t like special scoping, but their presence in Common Lisp is incredibly useful in practice, especially but not only for multi-threading!

Julia’s default representation for integers is either 32-bit or 64-bit integers, depending on the target architecture, which silently wrap around. Julia also supports “BigInts” that can be arbitrarily large, but you have to ask for them explicitly. In Common Lisp, integers are by default arbitrarily large, which I think is an advantage. Due to type tagging in Common Lisp implementations, even “big” integers are typically allocated as immediate values rather than on the heap when they fall into the “fixnum” range. I didn’t find anything in the Julia documentation that discusses this aspect of “BigInt.”

In Julia, all mathematical operations are generic functions and can be extended by user-defined methods. This is a strong advantage for Julia. In Common Lisp, mathematical operations are “plain” functions which cannot be extended. Due to some aspects in the design of Common Lisp’s generic functions, it’s hard to inline (or open-code) them, which is why for performance reasons, it’s better to express mathematical (and other such performance-critical functions) as “plain” functions. Apart from that, the support for number types seems to be on par between Julia and Common Lisp (complex types, rational numbers, floating point numbers, etc.)

In Julia, strings are unicode strings by default. My knowledge about unicode support in Common Lisp implementations is limited, so I cannot really make any comparisons here. One interesting aspect in Julia’s string support is that there can be user-defined macros to parse them and construct other syntactic entities out of them. This feels somewhat similar to read macros in Common Lisp, although with a slightly different scope.

Julia’s support for functions is similar to Common Lisp: They can be first class and anonymous (lambda expressions). There are varargs (&rest), optional and keyword arguments. In Common Lisp, optional and keyword arguments cannot be dispatched on in methods. In Julia, optional arguments can be dispatched on, but not keywords. (This is a pity, dispatch on keyword arguments would be very interesting, and is something I wanted to add as part of Closer to MOP for a long time!)

Julia’s support for control flow is much more limited than in Common Lisp. There are equivalents for progn, cond/if, for and while loops. Unlike Common Lisp, there is no support for a full loop facility, or even for a simple goto construct. Common Lisp clearly wins here. Julia’s support for exception handling is also limited: No handler-bind, no restarts, unlike in Common Lisp, which are also really useful features.

Julia’s type system has some interesting differences to Common Lisp: There is a distinction between mutable and immutable classes. Immutable classes disallow any side effects on their fields. This seems to be primarily directed at enabling stack allocation as an optimization. In Common Lisp, you would use dynamic extent declarations when allocating structs (or other data types) to achieve similar performance improvements. I’m not sure why it would matter that the fields need to be read-only for such an optimization, but if this covers most cases, maybe this is good enough.

Julia allows for returning and receiving multiple values from function calls, similar to Common Lisp. This is a feature I like a lot in Common Lisp, so I’m happy it’s also in Julia. In Julia, this is achieved by an explicit tuple type representation which doesn’t exist in this form in Common Lisp. In Lisp, you could also return/receive lists instead of multiple values, which would correspond to this kind of tuple type, but lists add an additional performance overhead, which multiple values and, presumably, tuples in Julia don’t have.

Julia supports parametric types. I don’t see at the moment why this is relevant. You could achieve similar functionality also with some macrology. Maybe I’m missing something here.

There is a whole section on constructors (make-instance / make-struct) in the Julia manual. This makes me suspicious, this should be an easier topic.

Julia has a module system. It supports export and automatic import of explicitly exported identifiers. You can also still access non-exported identifiers with additional syntax. This is good, because module designers may not always perfectly anticipate what users actually need to access. Common Lisp’s package system supports a similar distinction between external and internal definitions that can be accessed in different ways. I slightly prefer Common Lisp’s ability to use the package name as a prefix even for explicitly exported definitions. There is no feature in Julia to rename imported identifiers, which is something where Common Lisp’s support for explicit package name prefixes can come in very handy. I would like to see something like Oberon’s support for renaming identifiers on import in some Lisp dialect someday, because I believe that is the most complete solution for dealing with potential name conflicts.

In terms of meta-programming, apart from macros, Julia also supports (top-level) eval, like Common Lisp. Julia’s support for “reflection” is much weaker than Common Lisp’s CLOS MOP: You can only inspect types at runtime, but you cannot modify them (and language designers should stop calling something “reflection” that is clearly just “introspection”).

Both Julia and Common Lisp support multi-dimensional arrays. Common Lisp’s arrays are in row-major order, starting at index 0 in every dimension. Julia’s arrays are column-major order, starting at index 1 in every dimension. Julia’s support for multi-dimensional arrays is a library feature, whereas Common Lisp’s support is built into the language. Julia supports both dense and sparse matrices, where Common Lisp supports only dense matrices out of the box.

There are a lot of libraries that ship with Julia targeted at scientific computing.

Julia supports parallel programming with a model built on top of message passing: If you want to run parallel algorithms, you essentially start several instances of Julia that communicate with each other. The model does not support shared memory, and there is no multi-threading within a Julia instance (although there seem to be discussions among the Julia designers to add this in the future). The model is built on top of MPI as an implementation backend. However, the actual programming model supports single-sided communication: You can ask a function to be executed in some other Julia worker process, and can later synchronize with it to fetch results. On top of that, there are some high-level constructs provided as library features, such parallel maps and loops. Julia’s message passing model ensures that within a Julia instance, only one task is executed at a time, so there is yet no need to provide low-level synchronization mechanisms, such as locks or atomic operations. The lack of shared-memory parallelism is problematic because many parallel algorithms that are very easy to express with shared memory become quite complicated in a distributed memory setting. On the other hand, Julia’s model easily supports true distributed programming: You can configure Julia to run several instances across a cluster, and use them in a quite straightforward way: substantially easier than what you have to do with, say, MPI, and much closer with regard to ease of use to modern PGAS languages like Chapel or X10.

The ANSI specification for Common Lisp does not mention anything about multi-threading or parallel programming at all, but many Common Lisp implementations add support for shared-memory parallelism. I will not go into details here, but let me just briefly state that, for example, the LispWorks implementation of Common Lisp provides excellent support for symmetric multiprocessing that is at least on par with what you can find in most other language implementations in terms of parallel programming support. However, unfortunately, support for true distributed memory models seems almost non-existent in Common Lisp, apart for some basic support for MPI in a library that was maintained only for a very short period of time a couple of years ago. Julia looks like a good source of inspiration for adding such features to Common Lisp.

However, one aspect of Julia’s message passing approach seems problematic, as far as I can tell: You can pass closures between different instances of Julia, but it’s not clear how free variables in a lambda expression are bound. It seems that lexical variables are bound and serialized to another process, but global variables are not serialized and need to be present in any presence that may execute the closure. Experiments with adding side effects to free variables in lambda expressions that are passed to other processes seem to suggest that the semantics of this combination of features are unpredictable. At least, I have not been able to figure out what happens when — sometimes variables seem to be updated at the sender’s side, sometimes not — and I didn’t find a discussion of this topic in the Julia manual.

Anyway, as you can tell, there are a lot of interesting features in Julia, and it’s definitely worth a try.

The saga could end on Tuesday if the Board of Equalization, an elected tax board that has authority over personal income tax complaints, sides with Hyatt, now approaching 80.

The Franchise Tax Board, which conducted the audits that determined Hyatt failed to report income he earned in California, cannot appeal decisions by the Board of Equalization. If Hyatt loses, he’ll be able to pursue an appeal in civil court. In fact, he has a case moving forward at the U.S. 9th Circuit Court of Appeals.

But the clock is ticking on the Board of Equalization.

In January, it’ll lose most of its authority as California’s tax court and be replaced by a new Office of Tax Appeals. The new office will be staffed with appointed administrative law judges instead of the elected officials who now preside over tax disputes.

That means any delay this week could push the long-running case into the new tax appeal system lawmakers created in June when they voted to strip the Board of Equalization of most of responsibilities after a series of scandals suggested it had misused public resources and failed to properly allocate taxes among different government departments.

Board of Equalization member George Runner, who opposed the law that shrank his agency’s authority, said business owners like Hyatt and other companies are better off having their cases considered by the elected representatives.

“The ability to take this to a group of unbiased elected officials is better than taking it to a group of state employees who in the long run benefit from a decision for the state,” Runner said.

Hyatt’s high stakes case has twice reached the U.S. Supreme Court. Hyatt once won a judgment against California tax collectors that would have compelled the state to pay him $490 million, but the most recent Supreme Court case in 2016 capped the payout at $50,000. That lawsuit centered on what a Nevada jury considered to be heavy-handed tactics by Franchise Tax Board investigators who dug through Hyatt’s trash and scared off his potential business partners.

The Franchise Tax Board has already spent $25 million trying to collect the money while defending itself from Hyatt’s lawsuits, department spokesman Jacob Roper said.

“This is a well-known case, well documented,” Runner said. “It’s promoted and looked at as a very complex case, but in the end, it’s all about residency. Where did this individual live?”

README.md

# install.packages("devtools")devtools::install_github("EmilHvitfeldt/ggpage")

library(ggpage)

head(tinderbox, 10)## # A tibble: 10 x 2##                                                                           text##                                                                          <chr>##  1 "A soldier came marching along the high road: \"Left, right - left, right.\##  2 had his knapsack on his back, and a sword at his side; he had been to the w##  3 and was now returning home. As he walked on, he met a very frightful-lookin##  4 witch in the road. Her under-lip hung quite down on her breast, and she sto##  5 "and said, \"Good evening, soldier; you have a very fine sword, and a large##  6 knapsack, and you are a real soldier; so you shall have as much money as ev##  7                                                               "you like.\""##  8                               "\"Thank you, old witch,\" said the soldier."##  9 "\"Do you see that large tree,\" said the witch, pointing to a tree which s## 10 "beside them. \"Well, it is quite hollow inside, and you must climb to the ## # ... with 1 more variables: book <chr>

# Also pipeable# tinderbox %>% ggpage_quick()

tinderbox %>% 
  ggpage_build() %>% 
  ggpage_plot()

tinderbox %>%
  ggpage_build() %>%
  mutate(long_word=stringr::str_length(word) >8) %>%
  ggpage_plot(aes(fill=long_word)) +
  labs(title="Longer words throughout The Tinder-box") +
  scale_fill_manual(values= c("grey70", "blue"),labels= c("8 or less", "9 or more"),name="Word length")

library(ggpage)
library(purrr)
library(gganimate)prebuild<-tinderbox %>%
  ggpage_build() %>%
  left_join(get_sentiments("afinn"), by="word") midbuild<- map_df(.x=0:50*10+1,~prebuild %>% 
                    mutate(score= ifelse(is.na(score), 0, score), score_smooth=zoo::rollmean(score, .x, 0),score_smooth=score_smooth/ max(score_smooth),rolls= .x))p<-midbuild %>%
  ggpage_plot(aes(fill=score_smooth, frame=rolls)) +
  scale_fill_gradient2(low="red", high="blue", mid="grey", midpoint=0) +
  guides(fill="none") +
  labs(title="Smoothed sentiment of The Tinder-box, rolling average of")

gganimate(p, interval= .2)

Email, not Facebook, is the largest social network.

“We looked at the way news is consumed today on social media, with Facebook being the number place where all of that happens. A lot of publishers are talking to Facebook right now, but none of them know what Facebook is going to look like — it’s a platform controlled by a public company that has a lot of shareholders and other forces they need to answer to,” Austin Smith, Inside’s general manager, said. “Email will never be controlled in that way, and people are just as engaged with their inboxes as they have always been.”

It’s recently launched its paid subscription options for the newsletters at $10 a month for premium access to one newsletter, or $25 for premium access to an unlimited number of Inside verticals — a paid subscription removes ads and gets you…well, more emails. The more popular newsletters in the network average a “couple of hundred” paying subscribers; the smaller newsletters have around 50.

The newsletters also take ads: Either a company pays for a monthly sponsorship and gets a logo and callout in the newsletter, in addition to access to an Inside premium subscriptions bundle for their company, or advertisers can pay for more one-off native ads inside a newsletter (Inside doesn’t have an ad sales team so isn’t “super aggressive” about running them). Between ads and premium subscriptions, the company is not yet profitable (that’s “within eyesight,” it’s said) and may or may not be looking to raise funding in the meantime (“no comment”). Early on it had focused on metrics like opens-per-week, but with the rollout of subscription offerings, “enough readers are paying us so we don’t necessarily need to focus on volume as much as if we were only ad-supported,” Smith said.

Inside staffers float ideas for new topical newsletters to join the family, and readers “vote” by signing up to the potential newsletter with their emails; Inside will assign a writer and start a newsletter for ideas that collect at least 2,000 addresses (or attract a major advertiser to sponsor it). Some of the newer Inside newsletters such as Inside Trump, Inside Space, Inside Internet of Things, and Inside Beer all launched after hitting that minimum. Inside Bitcoin, for instance, went from the 2,000 pre-subscribers it had before anything launched to 7,000 subscribers a few days later.

“We found before we had the pre-subscribe feature, the most challenging thing for us was to get the first thousand, two thousand subscribers,” Smith said. It’s hard to get that word-of-mouth going when there’s nothing to build off of, and word of mouth is best way these things grow.”

Most of the company’s five full-time staffers and around 10 freelancers currently putting together all of Inside’s newsletters are tech-oriented generalists who have to cross multiple disparate beats. The team is still trying to figure out how much — and what — to offer premium subscribers, the right mix of original versus curation/aggregation, and the volume of new newsletters the team can handle. Several of the newsletters, such as the ones on Amazon and VR/AR industries, come out daily. News out of the Trump administration is so frequent that the twice-weekly Inside Trump digest has issued breaking alerts. Right now, Inside newsletters average about 60 to 70 curated content from other sources and up to around 40 percent original content, according to Kim Lyons, managing editor at Inside.

Premium offerings vary across newsletters. For some, a premium subscription comes with a occasional special research reports (e.g., Inside AI, written by angel investor in the space Rob May, compiles a monthly one). For others, it might mean one original article blurred out in a newsletter. (Inside’s newsletter CMS is built to handle toggling between paid-for and free content.)

“We try to make sure we don’t just have news of the day but news that you may have missed and is not getting attention elsewhere, and will take time to get our hands on an important issue that people are still only peripherally aware of,” Lyons said. “The most pushback we’ve had is from non-premium readers when they see an article they can’t read inside their newsletter, which we always knew was going to annoy some people who just don’t want to pay.”

“It’s still a process, building all this. But it’s super cool though to see readers actually do want to pay for it,” Smith said.

The SEC’s Office of Investor Education and Advocacy is warning investors about potential scams involving stock of companies claiming to be related to, or asserting they are engaging in, Initial Coin Offerings (or ICOs).  Fraudsters often try to use the lure of new and emerging technologies to convince potential victims to invest their money in scams.  These frauds include “pump-and-dump” and market manipulation schemes involving publicly traded companies that claim to provide exposure to these new technologies. 

Recent Trading Suspensions

Developers, businesses, and individuals increasingly are using ICOs – also called coin or token launches or sales – to raise capital.  There has been media attention regarding this form of capital raising.  While these activities may provide fair and lawful investment opportunities, there may be situations in which companies are publicly announcing ICO or coin/token related events to affect the price of the company’s common stock.

The SEC may suspend trading in a stock when the SEC is of the opinion that a suspension is required to protect investors and the public interest.  Circumstances that might lead to a trading suspension include:

• A lack of current, accurate, or adequate information about the company – for example, when a company has not filed any periodic reports for an extended period;

• Questions about the accuracy of publicly available information, including in company press releases and reports, about the company’s current operational status and financial condition; or

• Questions about trading in the stock, including trading by insiders, potential market manipulation, and the ability to clear and settle transactions in the stock.

The SEC recently issued several trading suspensions on the common stock of certain issuers who made claims regarding their investments in ICOs or touted coin/token related news.  The companies affected by trading suspensions include First Bitcoin Capital Corp., CIAO Group, Strategic Global, and Sunshine Capital.  

Investors should be very cautious in considering an investment in a stock following a trading suspension.  A trading suspension is one warning sign of possible microcap fraud (microcap stocks, some of which are penny stocks and/or nanocap stocks, tend to be low priced and trade in low volumes).  If current, reliable information about a company and its stock is not available, investors should consider seriously the risk of making an investment in the company’s stock.  For more on trading suspensions, see our Investor Bulletin: Trading in Stock after an SEC Trading Suspension – Be Aware of the Risks.

Pump-and-Dump and Market Manipulations

One way fraudsters seek to profit is by engaging in market manipulation, such as by spreading false and misleading information about a company (typically microcap stocks) to affect the stock’s share price.  They may spread stock rumors in different ways, including on company websites, press releases, email spam, and posts on social media, online bulletin boards, and chat rooms.  The false or misleading rumors may be positive or negative.  

For example, “pump-and-dump” schemes involve the effort to manipulate a stock’s share price or trading volume by touting the company’s stock through false and misleading statements to the marketplace.  Pump-and-dump schemes often occur on the Internet where it is common to see messages posted that urge readers to buy a stock quickly or to sell before the price goes down, or a promoter will call using the same sort of pitch.  In reality, the author of the messages may be a company insider or paid promoter who stands to gain by selling their shares after the stock price is “pumped” up by the buying frenzy they create.  Once these fraudsters “dump” their shares for a profit and stop hyping the stock, the price typically falls, and investors lose their money.  Learn more about these schemes in our Updated Investor Alert: Fraudulent Stock Promotions.

Tips for Investors

• Always research a company before buying its stock, especially following a trading suspension.  Consider the company’s finances, organization, and business prospects. This type of information often is included in filings that a company makes with the SEC, which are available for free and can be found in the Commission’s EDGAR filing system.

• Some companies are not required to file reports with the SEC. These are known as “non-reporting” companies. Investors should be aware of the risks of trading the stock of such companies, as there may not be current and accurate information that would allow investors to make an informed investment decision.

• Investors should also do their own research and be aware that information from online blogs, social networking sites, and even a company’s own website may be inaccurate and potentially intentionally misleading.

• Be especially cautious regarding stock promotions, including related to new technologies such as ICOs.  Look out for these warning signs of possible ICO-related fraud:
  • Company that has common stock trading claims that its ICO is “SEC-compliant” without explaining how the offering is in compliance with the securities laws; or
  • Company that has common stock trading also purports to raise capital through an ICO or take on ICO-related business described in vague or nonsensical terms or using undefined technical or legal jargon.

• Look out for these warning signs of possible microcap fraud:
  • SEC suspended public trading of the security or other securities promoted by the same promoter;
  • Increase in stock price or trading volume happening at the same time as the promotional activity;
  • Press releases or promotional activity announcing events that ultimately do not happen (e.g., multiple announcements of preliminary deals or agreements; announcements of deals with unnamed partners; announcements using hyperbolic language);
  • Company has no real business operations (few assets, or minimal gross revenues);
  • Company issues a lot of shares without a corresponding increase in the company’s assets; and
  • Frequent changes in company name, management, or type of business.

Additional Resources

Investor Bulletin:  Initial Coin Offerings

Updated Investor Alert: Social Media and Investing -- Stock Rumors

Investor Alert: Be Aware of Stock Recommendations On Investment Research Websites

Report possible securities fraud to the SEC.  Report a problem or ask the SEC a question.  Visit Investor.gov, the SEC’s website for individual investors.

The Office of Investor Education and Advocacy has provided this information as a service to investors.  It is neither a legal interpretation nor a statement of SEC policy.  If you have questions concerning the meaning or application of a particular law or rule, please consult with an attorney who specializes in securities law.

In the last seven months, Uber has endured:

• The #DeleteUber campaign
• The fallout from Susan Fowler Rigetti’s blog post, including the Holder investigation and report
• A lawsuit from Waymo alleging the theft of intellectual property
• Multiple revelations of past misconduct, including Greyball, which has prompted an investigation from the Department of Justice
• The forced resignation of founder and CEO Travis Kalanick, and then, earlier this month, an explosive lawsuit against Kalanick from the company’s biggest investor

And, at the end of all that drama — and this is only a partial list (as of the time of this writing Techmeme has had 280 posts about Uber in 2017) — Dara Khosrowshahi, the very successful, very stable, and very well-compensated CEO of Expedia, jumped at the opportunity to take the helm, beating out GE CEO Jeffrey Immelt and and Hewlett Packard Enterprise CEO Meg Whitman for the honor…it’s an honor, right?

In fact, I think Khosrowshahi is a great choice for CEO, and understanding why goes a long ways towards explaining why the Uber job remains an attractive one, even after the worst seven-month stretch in startup history.

Aggregation

Most news stories are making the obvious point that Khosrowshahi is qualified because he is a CEO for a tech company in the travel industry. What is even more relevant, though, is that Khosrowshahi is the CEO of an aggregator. Expedia and other online travel agents (and their associated stables of sites) have built businesses by focusing on discovery: instead of having to find hotels directly, a customer can go to Expedia and simply search for a location.

This, by extension, draws supply; while hotels may complain about having to pay OTA fees, the truth is the volume driven by the OTAs is well worth the cost — and Khosrowshahi has been willing to remind hotels of that fact. Indeed, Khosrowshahi had to learn just how powerful the effect of aggregation on suppliers can be. In an oral history on Skift about online travel, Khosrowshahi (who was then CFO of Expedia controlling-shareholder IAC/Interactive) recounted how it was that the company passed on Booking.com:

I think the Expedia team had taken a look at Booking.com and Active [Hotels, acquired by Priceline in 2005 and 2004, respectively] and again had passed. And, I think it was because we were attached to the merchant model and we were attached to high margins at the time.

The merchant model Khosrowshahi is referring to is where an OTA buys rooms at a wholesale rate and then sells them to end users; the advantage is a bigger margin on the sale of a room plus a positive cash cycle: the customer pays immediately but the OTA doesn’t pay the hotel until the stay occurs. The disadvantage, though, is that it requires making deals with hotels to buy rooms. Former Priceline CEO Jeffery Boyd, in the same oral history, explained what made Booking.com unique:

What the guys at Booking.com did the best really was that they understood how to basically address the entire market and not just the big chain hotels, the Accors and Marriotts and Hiltons in London, but ultimately leads to find demand for and service hotels in all countries, small towns, small hotels.

Booking.com used the agency model: instead of selling rooms at a markup Booking collected a commission on the rooms booked through its service. This meant significantly lower margins, no money until the stay occurred, and even then collection required some sort of enforcement mechanism.

The payoff, though, was tremendous: Booking.com, unlike Expedia, had minimal transactions costs for customers and suppliers. Hotels could sign up for Booking.com on their own instead of having to negotiate a deal, which meant it was Booking.com that led the industry in growth for many years; the full payoff of owning discovery in a world of drastically reduced distribution and transaction costs comes not from extracting margin from a limited set of suppliers, but rather from expanding the market to the greatest extent possible, creating the conditions for a virtuous cycle of more customers -> more suppliers -> more customers.

To Khosrowshahi’s credit he learned this lesson: Expedia was in big trouble in the years after he took over, and one of the changes Khosrowshahi made was to add the agency model to Expedia’s properties (Expedia now has a hybrid approach). It is a lesson that will serve him well as Uber’s CEO; the fundamental mistake made in so much Uber analysis comes from believing that drivers are the key to the model. For example, there was a very popular piece of analysis some months ago premised on evaluating the cost of driving for Uber relative to driving for a traditional cab company. It was a classic example of getting the facts right and missing the point.

In fact, what makes Uber so valuable — and still so attractive, despite all of the recent troubles — is its position with riders. The more riders Uber has, the more drivers it will attract, even if the economics are worse relative to other services: driving at a worse rate is better than not driving at a better one.

To that end, Uber’s strength — and its sky-high valuation — comes from the company’s ability to acquire customers cheaply thanks to a combination of the service’s usefulness and the effects of aggregation theory: as the company acquires users (and as users increases their usage) Uber attracts more drivers, which makes the service better, which makes it easier to acquire marginal users (not by lowering the price but rather by offering a better service for the same price). The single biggest factor that differentiates multi-billion dollar companies is a scalable advantage in customer acquisition costs; Uber has that.

Indeed, Uber’s position is in this respect stronger than Expedia’s: Expedia is an aggregator of sorts, but a huge portion of its audience in fact starts with a Google search, which means Expedia must pay Google a huge “tax”, in the form of search ads, to acquire users. Moreover, Expedia lives in constant fear that Google is simply going to fill the OTA role directly; that is why Expedia was a complainant in the EU’s antitrust case against Google. An even more pressing concern is Airbnb, which is forging its own customer relationship and own supply, and could (should?) move into hotel booking as well.

Finance

Expedia’s experience with Google as intermediary has its advantages: OTAs like Expedia and Priceline are, by necessity, the absolute best at testing and measuring the return on investment of outbound marketing, particular search advertising. That specific skill may not be particularly useful to Uber, but what the company certainly needs is a far more disciplined and exact approach to its accounting.

A few months ago, when Uber lost its head of finance Gautam Gupta, The Information reported that:

Financial-performance data tools that Uber executives use for internal purposes have a long way to go, according to two people who have been briefed about the issue. For instance, Uber until recently didn’t have a way to accurately calculate the amount in bonuses that Uber paid to drivers in, say, the past week.

As I noted in a Daily Update at the time, this is staggering: Uber cannot measure the “single most important factor in [its] profitability” on something approaching a real-time basis. Moreover, as I wrote then:

The implication of this lack of tracking is that Uber may not have a clear picture as to what its unit costs are; as I noted in a Daily Update last year about Uber’s unit economics, driver bonuses based on meeting a quota of rides in a specific time period are absolutely variable costs that should be allocated to a unit cost calculation. But, if Uber doesn’t even know what those costs are in anything approaching real time, how can it really know what its unit costs are?

No wonder Benchmark, the investor that is suing Kalanick, listed the lack of a CFO as a reason for its lawsuit. And in that light, Khosrowshahi’s finance background is an asset, not a liability. Nothing is more important for Uber than getting its books straight, because I suspect the company’s tactics might change as well. From that Daily Update:

It is worrisome that these bonuses are the key to profitability; I have long argued that Uber wins not by monopolizing drivers (i.e. supply) but by monopolizing riders (i.e. demand). And, optimizing for demand would suggest giving drivers a bigger cut of each ride such that marginal drivers (i.e. those that aren’t in a position to earn those volume bonuses) are encouraged to come on to the network and improve liquidity. Of course, higher driver payouts quite obviously impact unit economics; if bonuses, at least in Uber’s accounting, do not, then its easy to see how a suboptimal decision that favors bonuses over higher payouts could result. Accounting matters!

In other words, I think that Uber’s use of the bonus model with drivers has the whiffs of Expedia using a merchant model: it makes sense in the short term (in this case, monopolizing the time of professional drivers such that they can’t drive for the competition) but it ignores the long term value of having less friction for suppliers to come on board (that is, the part time drivers that overwhelmingly favor Lyft). Khosrowshahi’s painful lesson with Booking.com may be an advantage here as well.

Turnarounds

I noted that Expedia was in trouble at the beginning of Khosrowshahi’s tenure; in fact, the company’s situation deteriorated over Khosrowshahi’s first few years, culminating in a $2.52 billion loss for 2008. To be fair the biggest part of that loss was the write-down of intangible assets layered on top of the Great Recession, but the truth was that Expedia had been slumping for a long time.

In response Khosrowshahi did something that may have seemed quite risky: instead of trying to apply a quick fix to the business, he led a complete rebuild of the underlying platform that powered Expedia and its various house brands. This new platform not only enabled the shift to the agency model noted above, but dramatically improved the company’s ability to test and iterate its offering. Moreover, because the platform was designed to work with multiple brands, it set Expedia up for its recent acquisition binge, including Orbitz and HomeAway; critics say the company has bought growth, I say that owning more customer touchpoints, provided you can execute against them, is exactly what an aggregator should be doing.

The deeper takeaway, though, is that Khosrowshahi has demonstrated the patience and resolve to fix problems at their root. In the case of Uber, the business may be in better shape than Expedia’s was (pending the fixing of finance, of course), but as this year has made clear the culture needs a fundamental reworking, not simply a fresh coat of paint. Khosrowshahi seems like an ideal candidate to take on the problem at a fundamental level, and has already shown at Expedia that he is willing to walk the walk on issues of sexism in particular.

It is easy to mock Uber and the ridiculous CEO selection process that resulted in Khosrowshahi getting the job. Even the final selection process itself was a joke: in the span of 24 hours the presumed favorite shifted from Immelt to Whitman to the surprise selection of Khosrowshahi, with Uber reporters literally changing their stories by the minute as board members leaked like sieves in an attempt to rally public opinion to their sides.¹ Without question Uber has been horrifically served by its board of directors — all of them.

And yet, the company has landed on a candidate that I am quite enthused about, and that, I think, is a reminder of just why Uber is so compelling. So many tech startups blather on about changing the world; Uber actually is, for the better. To that end, I would argue that one of Kalanick’s greatest failings was in his inability to sell Uber: the company offers a compelling service for riders, an economically attractive one for drivers (who drive by choice), and makes the cities within which it operates better. That the company has managed to become a pariah is the most powerful testament there is to Kalanick’s failure as CEO.

To that end I hope Kalanick and the other members of the board truly give Khosrowshahi the space he needs to rework Uber’s culture, finances, strategy, and image. The fact of the matter is that Uber’s missteps have already cost it much of its global ambitions; Kalanick in particular needs to give the space for Khosrowshahi to aggregate the opportunity that remains.

1. As an aside, Immelt would have been a terrible choice: he has no relevant experience, particularly given his job at an old-line company with zero experience in aggregation effects. Whitman, on the other hand, pioneered the aggregation model at Ebay; however, because of Ebay it seems clear that Whitman was closely aligned with Benchmark, which may have made board dynamics with Kalanick untenable. Moreover, Whitman’s experience at HP-E isn’t really relevant at all [↩]

Loading dictionary...

The dictionary is available again in a minute.

Due to high load on the servers, the dictionary is currently not available.

README.md

go get -u github.com/henrylee2cn/teleport

Peer -> Connection -> Socket -> Session -> Context

HeaderLength | HeaderCodecId | Header | BodyLength | BodyCodecId | Body

typePacketstruct {// HeaderCodec header codec nameHeaderCodecstring`json:"header_codec"`// BodyCodec body codec nameBodyCodecstring`json:"body_codec"`// header contentHeader *Header `json:"header"`// body contentBodyinterface{} `json:"body"`// header lengthHeaderLengthint64`json:"header_length"`// body lengthBodyLengthint64`json:"body_length"`// HeaderLength + BodyLengthLengthint64`json:"length"`
}

typeHeaderstruct {// Packet idIdstring// Service typeTypeint32// Service URIUristring// Body encoding typeGzipint32// As reply, it indicates the service status codeStatusCodeint32// As reply, it indicates the service status textStatusstring
}

varcfg = &tp.PeerConfig{DefaultReadTimeout:   time.Minute * 3,DefaultWriteTimeout:  time.Minute * 3,TlsCertFile:          "",TlsKeyFile:           "",SlowCometDuration:    time.Millisecond * 500,DefaultHeaderCodec:   "protobuf",DefaultBodyCodec:     "json",DefaultBodyGzipLevel: 5,PrintBody:            true,DefaultDialTimeout:   time.Second * 10,ListenAddrs: []string{"0.0.0.0:9090",
	},
}varpeer = tp.NewPeer(cfg)// It can be used as a server
peer.Listen()// It can also be used as a client at the same timevarsess, err = peer.Dial("127.0.0.1:8080", "peerid-client")if err != nil {
	tp.Panicf("%v", err)
}

// Home controllertypeHomestruct {
	tp.PullCtx
}// Test handlerfunc(h *Home) Test(args *[2]int) (int, tp.Xerror) {a:= (*args)[0]b:= (*args)[1]return a + b, nil
}

// Msg controllertypeMsgstruct {
	tp.PushCtx
}// Test handlerfunc(m *Msg) Test(args *map[string]interface{}) {
	tp.Infof("receive push(%s):\nargs: %#v\nquery: %#v\n", m.Ip(), args, m.Query())
}

funcUnknownPullHandle(ctxtp.UnknownPullCtx, body *[]byte) (interface{}, tp.Xerror) {varvinterface{}codecName, err:= ctx.Unmarshal(*body, &v, true)if err != nil {returnnil, tp.NewXerror(0, err.Error())
	}
	tp.Infof("receive unknown pull:\n codec: %s\n content: %#v", codecName, v)return"this is reply string for unknown pull", nil
}

funcUnknownPushHandle(ctxtp.UnknownPushCtx, body *[]byte) {varvinterface{}codecName, err:= ctx.Unmarshal(*body, &v, true)if err != nil {
		tp.Errorf("%v", err)
	} else {
		tp.Infof("receive unknown push:\n codec: %s\n content: %#v", codecName, v)
	}
}

// AliasPlugin can be used to set aliases for pull or push servicestypeAliasPluginstruct {Aliasesmap[string]string
}// NewAliasPlugin creates a new NewAliasPluginfuncNewAliasPlugin() *AliasPlugin {return&AliasPlugin{Aliases: make(map[string]string)}
}// Alias sets a alias for the uri.// For example Alias("/arith/mul", "/mul")func(p *AliasPlugin) Alias(aliasstring, uristring) {
	p.Aliases[alias] = uri
}// Name return name of this plugin.func(p *AliasPlugin) Name() string {return"AliasPlugin"
}// PostReadHeader converts the alias of this service.func(p *AliasPlugin) PostReadHeader(ctxtp.ReadCtx) error {varu = ctx.Input().Header.Uriif p.Aliases != nil {if a = p.Aliases[u]; a != "" {
			ctx.Input().Header.Uri = a
		}
	}returnnil
}

aliasesPlugin:=NewAliasPlugin()
aliasesPlugin.Alias("/alias", "/origin")
{pullGroup:= peer.PullRouter.Group("pull", aliasesPlugin)
	pullGroup.Reg(new(Home))
	peer.PullRouter.SetUnknown(UnknownPullHandle)
}
{pushGroup:= peer.PushRouter.Group("push")
	pushGroup.Reg(new(Msg), aliasesPlugin)
	peer.PushRouter.SetUnknown(UnknownPushHandle)
}

package mainimport ("time"

	tp "github.com/henrylee2cn/teleport"
)funcmain() {go tp.GraceSignal()
	tp.SetShutdown(time.Second*20, nil, nil)varcfg = &tp.PeerConfig{
		DefaultReadTimeout:   time.Minute * 3,
		DefaultWriteTimeout:  time.Minute * 3,
		TlsCertFile:          "",
		TlsKeyFile:           "",
		SlowCometDuration:    time.Millisecond * 500,
		DefaultHeaderCodec:   "protobuf",
		DefaultBodyCodec:     "json",
		DefaultBodyGzipLevel: 5,
		PrintBody:            true,
		ListenAddrs: []string{"0.0.0.0:9090","0.0.0.0:9091",
		},
	}varpeer = tp.NewPeer(cfg)
	{group:= peer.PullRouter.Group("group")
		group.Reg(new(Home))
	}
	peer.PullRouter.SetUnknown(UnknownPullHandle)
	peer.Listen()
}// Home controllertypeHomestruct {
	tp.PullCtx
}// Test handlerfunc(h *Home) Test(args *map[string]interface{}) (map[string]interface{}, tp.Xerror) {
	h.Session().Push("/push/test?tag=from home-test", map[string]interface{}{"your_id": h.Query().Get("peer_id"),"a":       1,
	})returnmap[string]interface{}{"your_args":   *args,"server_time": time.Now(),
	}, nil
}funcUnknownPullHandle(ctxtp.UnknownPullCtx, body *[]byte) (interface{}, tp.Xerror) {varvinterface{}codecName, err:= ctx.Unmarshal(*body, &v, true)if err != nil {returnnil, tp.NewXerror(0, err.Error())
	}
	tp.Debugf("unmarshal body: codec: %s, content: %#v", codecName, v)return []string{"a", "aa", "aaa"}, nil
}

package mainimport ("time"

	tp "github.com/henrylee2cn/teleport"
)funcmain() {go tp.GraceSignal()
	tp.SetShutdown(time.Second*20, nil, nil)varcfg = &tp.PeerConfig{
		DefaultReadTimeout:   time.Minute * 3,
		DefaultWriteTimeout:  time.Minute * 3,
		TlsCertFile:          "",
		TlsKeyFile:           "",
		SlowCometDuration:    time.Millisecond * 500,
		DefaultHeaderCodec:   "protobuf",
		DefaultBodyCodec:     "json",
		DefaultBodyGzipLevel: 5,
		PrintBody:            false,
	}varpeer = tp.NewPeer(cfg)
	peer.PushRouter.Reg(new(Push))

	{
		varsess, err = peer.Dial("127.0.0.1:9090", "simple_server:9090")if err != nil {
			tp.Panicf("%v", err)
		}varreplyinterface{}varpullcmd = sess.Pull("/group/home/test?peer_id=client9090",map[string]interface{}{"conn_port": 9090},&reply,
		)if pullcmd.Xerror != nil {
			tp.Fatalf("pull error: %v", pullcmd.Xerror.Error())
		}
		tp.Infof("9090reply: %#v", reply)
	}

	{
		varsess, err = peer.Dial("127.0.0.1:9091")if err != nil {
			tp.Panicf("%v", err)
		}varreplyinterface{}varpullcmd = sess.Pull("/group/home/test_unknown?peer_id=client9091",map[string]interface{}{"conn_port": 9091},&reply,
		)if pullcmd.Xerror != nil {
			tp.Fatalf("pull error: %v", pullcmd.Xerror.Error())
		}
		tp.Infof("9091reply test_unknown: %#v", reply)
	}
}// Push controllertypePushstruct {
	tp.PushCtx
}// Test handlerfunc(p *Push) Test(args *map[string]interface{}) {
	tp.Infof("receive push(%s):\nargs: %#v\nquery: %#v\n", p.Ip(), args, p.Query())
}