jasonmoo

Plug alert: I am working with a company that's building a full representation of the Sanctum system using custom extensions of RISC-V (https://eprint.iacr.org/2015/564.pdf). There are critical features like root of trust key and entropy generation, and cache isolation that are missing from the vanilla RISC-V keystone approach. It offers a measure of security worth having but we're taking it all the way. We're working with MIT prof Srini Devadas. You can read more about it here if you're interested: https://medium.com/gradient-tech/announcing-gradient-crypto-...

Also we're hiring! https://www.gradient-tech.co/jobs

It looks like a ride-sharing service logo.

I've always wanted to do more with Sikuli. I could see it working well for this.

Sure but you can easily compose 4 services into a single representation and still have an appropriate amount of decoupling. Think of a dashboard.

graphql points toward this

https://github.com/facebook/graphql

microservices. the struggle is real.

It's interesting I think having an understanding of the history of javascript concurrency is almost a prerequisite to using it correctly. I wonder how new people approaching the language for the first time find it.

Sure. It's a simple tool but the concept could be augmented toward something like the scenario you described.

https://gist.github.com/jasonmoo/06691c8fea09b62aa35235fc93e...

I wrote the script in question and actually used a simple shannon entropy value. (http://codereview.stackexchange.com/questions/868/calculatin...). It worked well enough help rule out several problem spaces.

This is a great company. Golang developers welcome too!

Had that in mind when I named it.

go max!

This is great! Here's a demo of the full set to illustrate your point more fully.

http://play.golang.org/p/T1eJ4prBHM

sensible defaults

It's a pretty nice set of apis. I wrote an app that overlays the events feed onto google maps for geo eventin goodness.

http://nyevent.in

Source: https://github.com/jasonmoo/eventin

Nice. Yeah we built for our needs but happy to see it augmented.

Who has empathy for the empathic? At some level we all project our own issues and past experiences onto our picture of empathy. Meaning just because you can imagine how you would feel in a situation, doesn't mean that your subject feels the same. Empathy should season the dish of human interaction, not be the main course. Thanks for reading this.

Curious about the compare/contrast with 0mq.

    Step one: buy car service
    Step two: replace drivers with computers
    Step three: profit, optimize traffic patterns from within the swarm, decrease accidents, increase fuel efficiency, etc.

Omg you guys have no sense of humor.

I think the entire go spec would fit into the same number of pages as Guido's explanation of deferreds. zing!

Vimeo – NY, NY (Chelsea)

Check out all our jobs: www.vimeo.com/jobs

    * PHP Engineers (full-stack & backend)
    * Sr iOS Engineer
    * Site Reliability Engineer
    * MySQL DBA
    * Statistician
    * Web Analyst Manager
    * Digital Project Manager

Feel free to email our Tech Recruiter, tyler at vimeo dot com.

I made a bowl of spaghetti last night. Where was fox news on that one?

I'm curious to see if this is running with GOMAXPROCS above 1. I've seen the scheduler start to drag down reqs/sec with more than one thread in lightweight networking services like this.

Vimeo – NY, NY (Chelsea)

Check out all our jobs: www.vimeo.com/jobs

PHP Engineers (full-stack & backend)

iOS Engineer

DevOps Engineer

Data Operations Engineer

Marketing Web Designer

Stuff we use: PHP, Python, MySQL, Mongo, Redis, AWS, Solr, Hadoop, nginx, node, Vertica. And pretty much any mobile platform.

Posting for the author of Bifocals:

It's definitely not the easiest library to explain.

This does not explicitly use threads, but it will take advantage of any asynchronous systems you want to use.

http://bifocalsjs.com/#why-do-i-need-this-library is a more concrete example that might shed some light on the issue.

This allows you to run two database queries in parallel, and render immediately when the longest of the two queries is complete.

Most standard template systems have one large pool of data they provide to a template. You have to locate this data before you render a template, even if it is used by a partial.

Most partial systems simply combine two templates into a bigger template, that takes this large pool of data.

What bifocals does is give each partial it's own, isolated pool of data and render them separately and asynchronously from each other. This allows you to delay each partials rendering until it is ready, without waiting for the other partials to be ready.

Each function that creates Bifocals objects then can be isolated from the rest, with one sole responsibility. Render this template.

Your object might have parent objects, it might have children. Your function doesn't care, it just pumps data into a Bifocals object and marks it as ready. Bifocals then tracks your whole hierarchy, and sends it to the user when every last section is ready.

Posting for the author of Bifocals:

I'm not very familiar with express, but I just looked at the template system to see what I can do.

I don't think you would get a ton of benefit out of this library with express as is.

An express website would get the most benefit out of this library if they had a system so that the route your http server picked could also manually call routes which would add additional content to the page.

For example, something like the following would allow bifocals to work its magic.

    app.get(/^\/user\/(\d+)$/, function (req, res) {
        res.render('user.html', {user: req.params[0]});
    });

    app.get(/^\/home$/, function(req, res){
        app.perform_request('/user/1234', res.child('content',  'user_widget.html');
        res.render('home.html');
    });

Both times you see a user, they have executed the same route function, but you can change the templates and inject them into other templates asynchronously. You can do this unlimited times within one route, and to an unlimited depth (depending on your system resources of course)

Bifocals also offers some of it's own features, multiple rendering systems, http header+status code handling, and more.

Hey it's awesome to see you guys tackling a larger project in Go. I've been writing some smaller services/tools with it in my day job, and I like it a lot.

Thanks for sharing your work.

Yes! I don't think the memoization that you used in yours will work with the Varnish module format, but I think you had a good speedup even without that. For now we're just releasing the code.

This is the fully-functional, fast Varnish URL query string param sorter that won our coding competetion. I wrote about my entry a couple weeks ago: http://blog.jasonmooberry.com/2012/09/what-i-learned-from-my... This one beat mine by about 400k urls/sec. ~2.6m urls/sec.

We have been using it in production on our Varnish 3.0 servers for a couple weeks now and it's solid.

Go is a young language with a growing community that should only get better as more minds come to it.

For me it's very accessible for rapidly developing heavy-lifting tools, in particular networking tools. It's not the only language but it's served me well when I've reached for it.