Model View Controller isn't - <AUTHOR> http://beza1e1.tuxen.de/model_view_controller.html <comment><USER3> I tend to use the "model" and "view" concepts a lot when discussing architecture, but in my experience it's almost always a mistake to try and reference any specific MV* pattern for explanatory purposes - it does not have the effect of making the discussion clearer.

The issue is that there isn't actually a consensus about what constitutes the definitional features of these patterns, especially when it comes to how the concepts involved actually translate into code. For any sufficiently notable discussion of an MV* pattern, you're going to find an argument in the comments about whether the author actually understands the pattern or is talking about something else, and typically the commenters will be talking past one another.

Note that I'm NOT claiming that there's anything wrong with your favorite explanation of MV* - it may be perfectly well defined and concrete and useful once you understand it. The issue is a feature of the community: lots of other people have a different (and possibly worse) understanding of what MV* means, so when you start talking about it and your understandings don't align, confusion arises. Getting those understandings back in alignment is more trouble than the acronyms are worth.

I've seen enough conversations about concrete development issues suddenly turn into disagreements about the meaning of words to realize that nothing useful is conveyed by mentioning MV* and assuming anyone knows what you're talking about - it's better to spell out exactly what you mean in reference to the code you're actually talking about, even if you have to use more words.

<comment><USER4> I think there is an essential core of an idea in "MVC" which sustains across all of its interpretations/implementations.

The core idea is: you want to keep a firm separation between UI code (view) and object-oriented business logic (model).

Other objects will need to reuse your model as your application grows; UI code will clutter that reuse. For example, your business logic should return an array of Customers, not an array of UI labels. The business logic shouldn't directly refer to UI code at all.

In addition, you'll probably want to reuse some of your UI code in multiple contexts. A fancy resizable scrollable table shouldn't directly refer to Customers, because you might also want to use it to display a list of Purchases.

But if the business logic shouldn't directly refer to UI code, and UI code shouldn't directly refer to business logic, then you'll need _some_ code to bridge the gap. That's the controller.

But this idea still leaves a great deal open to interpretation. How much work should the controller do, vs. pushing that work to the model or the view code? What's "business logic" as opposed to "view logic"? Should the controller code be a single object? Is your view logic complicated enough (and reusable enough) to justify separating it out into another object (a "view model")? If you never write any reusable view code, do you even have/need MVC? All of these questions are unresolved by "MVC."

<comment><USER5> But I doubt that this core idea is what the original MVC idea had in mind.

I believe the original idea was that the MV and C are separated but coupled. So all views that bind to a model will update at the same time when a controller calls a change in the model.

On the web this concept is strange. I think this is why there are so many different MVC concepts.

</comment></comment></comment><comment><USER6> In my experience, the most common way people get MVC wrong is equating "model" to "data model", and "controller" to "business logic". Since the controller is responsible for also interacting with a specific view, you haven't made your software decoupled, rather just spread logic into three buckets.

IMHO, the real goal is establishing a somewhat stable boundary between the business logic and state and your UX, both to allow logic to be reused in other presentations and to allow both to evolve without constantly breaking code.

MVC vs MVP or MVA is a difficult distinction IMHO, because the UX portion is really split between the view and controller, which may also include interactions with a more sophisticated UI system (for example, with its own input event handling and data binding). For a lot of these systems, what constitutes a "View" or a "Controller" really depends on the infrastructure provided to the developer.

Template-based web frameworks can actually be fairly close to MVC - <USER2> controller handling the input request, translating that to commands against the model, and then taking data from the model and handing that off to the view to present to the user.

A component-based system has components which constitute the UI presentation, but also handle user input and may have data binding. At this point you are far closer to "Model View Adapter", which as the article points out is what you'll see in most componentized frameworks.

Again IMHO, but the difference between MVA and "Model View ViewModel" (MVVM) are really around implementation strategies for the adapter layer. That there are different strategies is one of the reasons that attempts by frameworks to simplify this adapter layer result in different terminology (for instance, ViewControllers and Delegates and DataSources, vs ViewModels)

</comment><comment><USER7> From the conclusion:

> If you design a system, it is not helpful to consider options like MVC vs > MVVM vs MVP. Instead, identify potential problems and if necessary solve > them.

I think that's a pretty good take on it. There's an annoying tendency for most conversations including the notion of MVC to devolve into nitpicking about which variant is actually being discussed and whether some architecture is 'really' MVC or something else that looks like it.

Its main value is in an abstract principle that it references: when modeling something, it's useful to separate a thing's essence from _representations_ of that essence (the Model in MVC would be the essence and Views representations). This is an idea that shows up all over the place; it's almost certainly related to human cognitive structure in some way. (The Controller component is more arbitrary; you can see it pointed out in the article also that it was more related to implementation than the more general Model/View concepts.)

One way I've found useful for thinking about the principle is in terms of causality within a system. When you're separating out the model/essence from the view/representation portions of a system, the most important distinction is: the essence carries all the information necessary to _determine_ (a configuration of) the representation. In this case, you can set up a mapping from the essence to the representation once; after that, you can stop thinking about the view/representation because changes to the model/essence already cover everything.

It's a very general kind of information compression that helps us manage system complexity by creating causal hierarchies.

(An example of another kind of 'causal hierarchy' I was thinking about recently: the decomposition of changes in position in Newtonian mechanics ultimately to forces (rather than working with e.g. velocity directly). If you know about the forces (and mass), they imply everything you need to know about acceleration, from which you may deduce, velocity, and then position. Once you have that mapping from force->acceleration->velocity->position your mind is freed up to only thinking about forces.)

<comment><USER8> > _When you 're separating out the model/essence from the view/representation > portions of a system, the most important distinction is: the essence carries > all the information necessary to determine (a configuration of) the > representation. In this case, you can set up a mapping from the essence to > the representation once; after that, you can stop thinking about the > view/representation because changes to the model/essence already cover > everything._

How does this work when you have to deal with animations, or state that you don't want to commit until the user completes a gesture or activity, or complex transitions between screens? It's not necessarily a good idea to shove all that stuff directly into the model.

I think if you treat the Controller as a mere implementation detail, your interfaces will lack liveliness. Simulation time and running user input are just as essential to the view as any changes to the model. That's (IMO) what the Controller is there for: to encapsulate that sort of temporal complexity.

<comment><USER7> TL;DR: I'm experimenting with that problem now. Currently I'm trying out this idea of 'transient state' described more below.

\</comment></comment></comment><comment>-

I've actually been working on something that deals a lot with that problem. It's a game with all the rendering done in a single pixel shader.

All the gameplay logic is in a class called GameStateTransformer. The idea was to treat the game like a dynamical system where the state evolves as a function of 1) time 2) a sequence of 'events'. The core of it is a loop that runs 60 times per second, evolving state via time-dependent logic and by grabbing/processing any events in the queue at that time.

The rendering (i.e. view) is connected to the state (i.e. model) by executing a function `mapStateToUniforms()`[0] every frame. It always works the same way regardless of whether there is an animation going on or whatever; animation logic just updates parts of the state that will get mapped to GLSL uniforms (mostly it's things like `deathAnimRatio` taking on values between 0 and 1.)

The situation with events taking place over time was certainly the most complex architectural aspect I had to deal with. There were two main things I used:

1) 'transient state'; I would set up a bit of temporary/transient state by making a call like `runTransientState('player.dying', {deathPosition: blah}, 1.5)` —first arg is a path into the state object, second is a 'data' object, third is the amount of time it should remain in the state. After that call my state object would contain something like `{..., player: {..., dying: {position: blah}}}` So other code could check `if (state.player.dying)` and access related sub-data (e.g. `state.player.dying.position`); and that part of the state would be deleted after 1.5 seconds.

2) Emitting events at key points during animations/transitions (generally when they finish). Also the 'transient state' system always emits an "[transientStatePath]_finished" event when a bit of transient state's time runs out (e.g. "player.dying_finished").

There was another subsystem I put in place related to this which I haven't had to use much so far though: 'contingent evolvers', which are objects that define a `condition(state)` function and an `evolve(state, deltaTime)` function, and are automatically only executed while their condition is met.

Not positive how well this would scale to larger applications, but it has worked well for the game so far.

Source is here if you're curious: [https://github.com/westoncb/under- game](https://github.com/westoncb/under-game)

[0] For those unfamiliar with GLSL 'uniforms' they are variables passed into your shader from the application code. Since all of my rendering is in a pixel shader, the code there is function of the current values of the uniforms + x,y coordinate of some pixel.

</comment><comment><USER9> I've always found MVC or any flavor of it to be a flawed paradigm. Instead, a separation of APIs, and clients that consume them, is a more pleasant way to work with things that need a view layer. "Controllers" are undefined things. We get frameworks like Rails that encourage spaghetti code placement (and make spaghetti a first class citizen), because the fundamental concept of a controller doesn't make sense.

<comment><USER6> MVC actually works really well for a HTTP framework like rails, because the separation of input (the controller) and output (the view) fits well when your model is based on request/response.

Rails goes a bit far in pushing for your model to be built around your database-backed data model (but does properly push you to include data integrity and business logic there as well).

Since there is not object classification in rails called Spaghetti, I can't really speak to it being a first class citizen in rails - nor can I guess which of Rails' shortcomings you are referring to.

Even with a client/API separation, your API still has input, output, and business logic - the three components of MVC. An API can benefit from having MVC once it has multiple views; for instance, if you later find you must support different clients utilizing multiple concurrent versions.

In that vein, I consider a framework like Sinatra to be controller-centric - with both the model and view layers being optional and bring-your-own. I've certainly used it as MVC.

<comment><USER9> > your API still has input, output, and business logic - the three components > of MVC

 _what_

</comment></comment></comment><comment><USER10> My understanding of the Model-View-Adapter pattern is that the adapter is the dependant of both the view and the model, which are disjoint objects. The diagram shown here has the arrow inverted between the adapter and the view, and the author mistakenly assumes it is isomorphic to the MVVM pattern. This might seem nitpicking, but it's an important distinction. In the MVA pattern, the adapter is the only thing that knows about both the model and the view, ensuring that the two are cleanly separated.

The MVA pattern is underused. People have a tendency to make their views dependant directly on the model, or vice-versa, and often don't keep a clean separation.

<comment><USER11> I'd say the MVA (or MVP, or Apple MVC) pattern is _overused_.

There is usually neither a point to separating the view and the model like that, nor is it usually possible. In practice, you get lots and lots (and lots and lots) of glue code that is (a) boring, (b) repetitive, (c) error-prone and (d) non-reusable.

The code is non-reusable because it is specific to both the view and the model. And it doesn't usually help in keeping the view model-agnostic, because after all the view is there for displaying the data that's in the model. Additional layers can't change that fact.

See also: Massive View Controller.

<comment><USER12> > "because after all the view is there for displaying the data that's in the > model."

I wouldn't disagree. But I also believe there's another way to look at the view, and that is as the interface between the application and the user. That UI has or needs to have (design) patterns, a la Atomic Design for example.

[http://atomicdesign.bradfrost.com/](http://atomicdesign.bradfrost.com/)

For example, a list is a list is a list. In a well designed UI / UX that will follow / maintain a pattern. At that point, there's no real relationship per say to particulars in the model. The view / partial is "free standing" and can be repurposed as required. In the mind of the view, there is no model.

Maybe I'm splitting a hairs and/or have gone off on a tangent? My apologizes.

<comment><USER11> Hmm...

> a list is a list is a list.

I would think that to be useful, a list will be a _list of something_. And that something will almost certainly be domain/model specific. Even if you expose just a list of strings, those strings will have some sort of semantic actions associated with them.

<comment><USER12> Yes. But it's not (or shouldn't be) a one to one between view and model. At least that particular view should be independent.

Note: It was simply a basic example. The crux being to also look at the view from the frontend - user and frontend dev, and not only from the model forward.

Fwiw I've recently taken over a project where I've found the same essentially partial four times. Not fatal, but more to maintain, as well as confusing when you're trying to unscramble things.

</comment></comment></comment></comment></comment><comment><USER13> people... two things:

* MVC is not only about user interaction/UI. User interaction/UI is just most used area. i have used MVC inside a compiler, and inside data-crunching-pipeline. Fits perfect, as long one abstracts oneself from what user/business means.

* MVC is not single thing, it's a fractal idea. The View (may) has its own internal MVC (e.g. in UI: a widget, i.e. scrollbar), Model has its own (e.g. somewhat around ORM), ... and this may go further down - or up.

* it's a general concept saying that 3 islands/aspects talking to each other are needed for complete system; 2 are too few, 4 might be too many.

have fun

</comment><comment><USER14> The biggest problem is that the Web doesn't fit GUI's well. MVC and its variants are an ugly fudge, largely to make the stateless Web protocols "seem" stateful. One has to split the work up into bigger teams to do something that was easy, trivial, one-man-band work in things like Powerbulder, Delphi, Oracle Forms, etc. We devolved from the 1990's, turning bicycle science into rocket science. Our Oracle Forms team is 4x more productive than our MVC team. It's embarrassing. Sure, the web apps are arguably "prettier", but at a cost. (If not for Java security going bad, our org would keep using Forms. Oracle should have kept the "EXE" based client.)

</comment><comment><USER15> I'm not dogmatic about MVC (or any similar acronym), but I think MVC serves as a good reminder to (follow the more agreed upon maxim to) separate your concerns. Your application logic, data, and presentation layers need not be intertwined.

<comment><USER16> Like everything it's a tradeoff. A signup page that just collects email addresses does not need to care about architecture.

Best practices always have the hidden assumption that going deal with the same situations as 99/100 cases. But, clearly that's not always true, so you need to keep in mind the reasoning behind them.

</comment></comment><comment><USER17> I think part of Controller should be in the Model, because I often found business logic is highly coupled with the data.

I've more often used the Model-View pattern, where the business logic was inside the Model.

What I have decoupled from the above is State controllers though; State controllers have to do with the application itself, they have nothing to do with the data or the presentation of them.

</comment><comment><USER18> I like Clean Architecture. There is a particularly annoying, but powerful piece: the Presenter. While it makes for some awkward code, it does separate concerns.

The controller has a use case, which is the business logic, injected into it. The controller also has the Presenter injected into it. The controller invokes like so: UseCase.execute(input, Presenter).

The use case does its thing. Then calls presenter.present(ResultData). The presenter can be responsible for creating the actual response on the wire. It is also responsible for getting data from the database for lists, and other UI features. Finally, the Presenter invokes whatever machinations are required write update the client. In the case of HTML, the presenter knows which template to invoke. In JSON, just serialize the output.

What's awkward about it is the .present when in failure, which in Go is all the time.

if err != nil { presenter.present(FailureStruct) return }

This is repeated all over the place. That return is important. Since the result is not returned from the UseCase, getting this wrong could lead to failure.

In my code, the Unit of Work is managed by two entities: the controller and the presenter. The controller gets everything warmed up. The presenter knows when all the data calls complete. If the presenter is for an HTML page that needs to get data, the presenter is essentially a micro controller that couples the use case to the view.

All of this is tucked away nicely. The domain gets to drive a lot. Everything is testable since the presenter is

type CreateUserPresenter interface { present(Output) }

Interfaces for everyone. Use Case has interfaces for the domain repositories it needs. Controller gets injected, or in my case calls a factory, the use case and presenter.

Things are actually decoupled. No more transaction scripts spread across multiple thinly veiled layers.

<comment><USER19> Why is the result not returned from the use case?

<comment><USER18> To truly seperate the controller from the process of invoking the use case and view. A better question is why does the use case have the presenter pushed as part of the invocation? You could easily have a use case take an input and nothing else. Why have the controller get an instance of the presenter, pass that to the use case, then have the use case call the presenter? The answer is that it makes explicit the fact that there will be a response. It also allows the controller to either directly, or indirectly, more likely indirectly, get the UI component ready.

In my codes case, the presenter is gained through a factory method. The factory takes the response for the request, context and that's it. It creates the REST response handler that holds onto the response struct, in Go. This allows the system to safely switch the thread underneath the actual request/response of the handler. Since the Use Case gets the presenter as an argument, it naturally carries the presenter when the thread changes without having to store it into the Context.

All of this fits nicely with Go. Go handlers return void. So in the handler, my controller, the use case kicks off, and the handler is done. The presenter sets the response code, body, and anything else.

For more information. [https://softwareengineering.stackexchange.com/questions/3570...](https://softwareengineering.stackexchange.com/questions/357052/clean- architecture-use-case-containing-the-presenter-or-returning-data)

</comment></comment></comment><comment><USER20> The absolute most important thing to understand about models as they were originally intended, is that they are not descriptions of a data model per se.

This is not to say that data modeling is not important, or that your model won't have a similar shape as your data model; it will. But that is not the original point.

In MVC as it was originally understood, a model is a list of subscribers. You can add yourself to that list, you can remove yourself from that list, and whenever a "value" changes, if you are on that list, you get a notification that the value has changed. You have a couple of different designs of these, depending on whether you want to send a current-state message as a notification on subscription, or just give everybody read access to the current state. The latter commits you to initializing your models in ways that indicate the absence or staleness of data (someone loads your app, you need to send out a network request to get a new thing) but also allows you to use variable scope to augment how much multiplexing and state tracking you need.

Models vary from data models in having view-relevant data. So for example you switch from the type

        const urlList = new Model<UrlRow[]>([])

to the type

        type Fetching<x> = { state: "init" }
          | { state: "loaded", data: x },
          | { state: "fetching", staleData: x },
          | { state: "fetch error", staleData: null | x }
        const urlList = new Model<Fetching<UrlRow[]>>({
          state: "init"
        })

Notice that these Fetching indicator statuses are a part of the data model for the UI, not the underlying data model that exists at the database level.

If this begins to feel a lot like React and Redux, that is because there is a shared lineage there. React originally made its splash as "the V in MVC" but its setState/state system, while it doesn't contain a subscriber list, effectively does something equivalent by insisting on destroying anything that has the old values and then superficially identifying things which appeared to remain the same from moment to moment, with the basic model then being a "subscription tree."

Redux of course takes this from being a tree to being something more generic by making the store global... I think that models should not be app-global the way that Redux likes (it does not want to solve the problem of multiplexing models, which is understandable but it turns out to be a much simpler problem than you'd think) and that the pattern of reducers is more verbose than one generally needs, but I love the time travel browser features that Redux gives me. Somehow Redux has encouraged abominations like redux-thunk which complect separate concerns into the same dispatch function unnecessarily. But the fundamental workings involve that same basic structure: a subscriber list.

<comment><USER21> Hi, I'm a Redux maintainer.

Could you clarify why you feel that redux-thunk is an "abomination"? What specific concerns do you have?

I wrote a post a while back that answered several concerns I'd seen expressed about using thunks [0], and my "Redux Fundamentals" workshop slides [1] have a section discussing why middleware like thunks are the right way to handle logic [2].

Also, what do you mean by "multiplexing models"?

[0] [https://blog.isquaredsoftware.com/2017/01/idiomatic-redux- th...](https://blog.isquaredsoftware.com/2017/01/idiomatic-redux-thoughts-on- thunks-sagas-abstraction-and-reusability/)

[1] [https://blog.isquaredsoftware.com/2018/06/redux- fundamentals...](https://blog.isquaredsoftware.com/2018/06/redux-fundamentals- workshop-slides/)

[2] [https://blog.isquaredsoftware.com/presentations/workshops/re...](https://blog.isquaredsoftware.com/presentations/workshops/redux- fundamentals/side-effects.html#/4)

<comment><USER20> Hi! I would love to read your articles and discuss this further but right now your blog is not viewable by Chrome, Firefox, or Edge. Firefox gives the most descriptive error string as SSL_ERROR_RX_RECORD_TOO_LONG.

Multiplexing two models together to my mind just constructs a new model whose values are tuples of the existing models and which subscribes to both of those models in order to notify its own subscribers whenever either side of those tuples change. If you do this, you can have a bunch of local stores and still say "this component's value changes whenever either of those values change." The key is that "normal" models accept a set(value) message to set their value to something, and you might play around with "dict" models which accept insert(key, value), deleteAt(key) messages, but a multiplex model would not be easily able to abstract over all the different possible messages to send upstream and so the easiest approach is just to make multiplexes nonresponsive -- you can't "dispatch" to them, in Redux terms.

redux-thunk is nice in that it helps keep people from making the mistake of sending otherwise-no-op actions to the store which then, inside a reducer as side-effects, do a bunch of async I/O to compute events that eventually make it back to the store. I would broadly agree with that.

My basic beef with redux-thunk is that it's unnecessary and complicates what would otherwise be a type signature that has no reference to I/O, which I regard as a good thing. Developers ought to know that, to quote one of the Austin Powers movies, "you had the mojo all along." It's a sort of talisman that you are using for purely psychological reasons to reassure developers and to coax them to doing updates outside of the reducers, but it's OK because "it's in `dispatch()` so it must be a Redux thing so we'll make it work." But such a talisman is unnecessary.

Like, here's what you've got (in the readme):

        function makeASandwichWithSecretSauce(forPerson) {
          return function (dispatch) {
            return fetchSecretSauce().then(
              sauce => dispatch(makeASandwich(forPerson, sauce)),
              error => dispatch(apologize('The Sandwich Shop', forPerson, error))
            );
          };
        }
        store.dispatch(
          makeASandwichWithSecretSauce('Me')
        );

Here it is with simpler type signatures:

        function makeASandwichWithSecretSauce(forPerson, dispatch) {
          return fetchSecretSauce().then(
            sauce => dispatch(makeASandwich(forPerson, sauce)),
            error => dispatch(apologize('The Sandwich Shop', forPerson, error))
          );
        }
        makeASandwichWithSecretSauce('Me', msg => store.dispatch(msg));

The indirection here wouldn't even be necessary if Redux core just preventatively declared when creating a store that

        store.dispatch = Store.prototype.dispatch.bind(store);
        store.getState = Store.prototype.getState.bind(store);

which I mean maybe you do; I don't know.

<comment><USER21> Erm.... that's bizarre. Should be a normal Let's Encrypt cert as far as I know. Are you accessing it through some kind of corporate proxy that's blocking it or something? Does that happen on any other machines?

Anyway. Reading the rest of your comment...

I'll be honest and say that you pretty much lost me in that discussion, as in, I genuinely am confused what you're trying to say. I'll try to give some thoughts here, but I don't know if this is going to answer things because I don't know what point you're actually trying to make.

The point of `redux-thunk` is to allow you to write logic that needs access to `dispatch` and `getState` when it runs, but without binding it to specific references of `dispatch` and `getState` ahead of time.

If you wanted to, you _could_ just directly `import {store} from "./myStore"`, and directly call `store.dispatch(someAction)`. But, A) that doesn't scale well in an actual app, and B) it ties you to that one store instance, making it harder to reuse any of the logic or test it.

In a typical React-Redux app, the actual specific store instance gets injected into the component tree by rendering `<Provider store={store}>` around the root component. As my slides point out, you _could_ still directly grab a reference to `props.dispatch` and do async work in the component, but that's also not generally a good pattern. By moving the async logic into its own function, and ultimately injecting `(dispatch, getState)` into that function, it's more portable and reusable.

Also, have you seen the actual implementation of `redux-thunk`? It's short enough that I'll paste it in here just for emphasis:

        return ({ dispatch, getState }) => next => action => {
            if (typeof action === 'function') {
                return action(dispatch, getState);
            }
            return next(action);
        };

If you can try to clarify what you're saying about "type signatures" and binding the methods from the store, I'd appreciate it. (Actually, that bit about binding the store methods doesn't make any sense, because a Redux store isn't a class - it's a closure, so there's no `this`.)

If you're available to discuss this in a venue that may be better suited for it, please come ping me @acemarke in the Reactiflux chat channels on Discord (invite link: [https://reactiflux.com](https://reactiflux.com) ).

<comment><USER20> Hm. I will have to retry. You're right that this is my work laptop and sometimes Sophos does weird crap. Sorry for alarming you without checking downforeveryoneorjustme first.

I have read the source; indeed reading the source of redux-thunk was necessary for me to conclude it was pointless. I like everyone else thought that it was doing something more than `go = fn => fn()` does.

The code that I wrote you is logic which needs access to `dispatch` and `getState` when it runs, but it is not bound to specific references of `dispatch` and `getState`. It does not use your hack of importing a store from a global location, so it does not have problems with (A) or (B).

You cannot avoid grabbing that reference to props.dispatch either way. The crux of the argument that redux-thunk is just syntactic sugar, is that dispatch is already in scope whenever it is used and can be passed as an argument or a closure.

I agree somewhat with refactoring async logic into its own component when one wants to reuse it and make it portable. The question is just, should you pass `dispatch` and/or `getState` as an argument to that function? Or should you curry that dependency to a subfunction and pass that function as an argument to `dispatch`?

I opine that the latter is objectively worse than the former. You have `dispatch`: hand it directly to the function, let people know that this function is not an actual action but an asynchronous process. We are talking about a syntactic sugar, in other words, that doesn't make anything sweeter.

I'm actually refreshed to be reminded that the Redux store is a closure, I had forgotten since I first read the Redux code several months ago. So then it's even easier; one never has to bind anything.

I will try to ping you on Discord later tonight; there is a specific reason that I am preferring asynchronous messaging systems at the moment.

</comment></comment></comment></comment></comment><comment><USER11> Yep: [https://blog.metaobject.com/2015/04/model-widget- controller-...](https://blog.metaobject.com/2015/04/model-widget-controller- mwc-aka-apple.html)</comment>


Valve to crowdsource distribution choices with Steam Greenlight - <AUTHOR> http://arstechnica.com/gaming/2012/07/valve-to-crowdsource-distribution-choices-with-steam-greenlight/ <comment><USER2> I'm kind of surprised they haven't tried a sort of kickstarter model.

E.g. People commit to buying your title, and when you hit the threshold they get billed (and get the game), and the game instantly gets approved to into main Steam. The required minimum could be based on revenue rather than sales , so that a $1 game requires a lot more potential buyers than a $40 game.

<comment><USER3> Steam would need to ensure each game is completed. It would tarnish the brand if some games were not finished. Kickstarter does not suffer from this problem because everyone goes into it expecting that the game may not get off the ground.

<comment><USER2> It would not be for pre-funding. A completed game (or at least nearly finished beta) would need to be submitted through some sort of basic approval process - scan the installer for viruse, make sure it actually loads, etc.

</comment></comment></comment><comment><USER4> This is great! hopefully it can deliver on the promise that XBox Live Indie Games never quite delivered on ... which is to say giving indies a channel to the same marketplace, on the same terms, as everyone else. The problem with XBLIG was always that the indie games were always in a different menu and never quite given the same opportunities as other titles (ie. XBLA had achievements, etc.).

<comment><USER5> To be fair I've played a lot of indie games on xbox live and a lot of them feel like their based off of a bad programming tutorial. It's fun to play them and go WTF why, definitely not something they should promote to a larger audience. It looks like Valve is solving the problem by having their customers go through the indie game bin and pull out the ones that are actually good.

<comment><USER6> You make is sound like all Xbox Live Indie Games are bad. The problem with that service is that which is mentioned above, not enough recognition as "official" apps for the Xbox 360. I'm convinced that if developers where given more responsibility then they would act upon that higher responsibility accordingly. As it is now developers really don't have much of an incentive to make decent games for the platform. But Valve's way of doing this seems to be a good one, let the customer's decide what gets on Steam, you really can't go wrong with that strategy.

<comment><USER4> Well said. Also, the very fact that the service allowed lower quality games is actually a good thing ... many game developers made well received titles on XNA and have moved on to bigger and better things (see Ska Studios, and Zeboyd Games for two examples).

<comment><USER6> Very true, in a way Xbox Live Indie Games is a lot like the Android Market Place. You have a wide variety of apps that are really very good but you also have a lot of complete crap. If Microsoft would ever actually follow through with it's experiments then it could really become a true power house again, it seems that Microsoft tends to innovate but then burn out on their innovations (keep in mind that Indie Games launched in 2008, right around the same time that the Android Market Place was really blowing up). I just wish Microsoft would give Indie Games the attention it desperately needs.

</comment></comment></comment></comment></comment><comment><USER7> Nice. This is a great way to deal with Sturgeon's Law.

<comment><USER8> Link: <http://en.wikipedia.org/wiki/Sturgeons_Law>

</comment></comment><comment><USER9> I just fail to see the big deal behind this. Really, isn't the games market enough to crowdsource distribution choices? This is only needed because Steam is a closed platform, which people seem to forget.</comment>


Russ Roberts and the Quest to Make Economics Interesting - <AUTHOR> http://priceonomics.com/russ-roberts-and-the-quest-to-make-economics/ <comment><USER2> Though I find his understanding of statistics to be off sometimes, I am very grateful to Russ Roberts for this podcast, which as taught me an enormous amount.

<comment><AUTHOR> He approaches stats as a user of them, and a skeptical one at that. I find it similar to a user of software to sometimes get the mechanics wrong, but still having a healthy skepticism against the hype.

I learn a lot too. It makes my Monday morning commute that much more tolerable.

</comment></comment><comment><USER3> I've been listening to EconTalk since late 2006. Gosh, it's been nearly 10 years!</comment>


Contracts give Coca-Cola power to 'quash' health research, study suggests - <AUTHOR> https://www.cam.ac.uk/research/news/contracts-give-coca-cola-power-to-quash-health-research-study-suggests <comment><USER2> Why is anyone doing health studies on soda and what the hell did they expect to find? That it would be good for you?</comment>


Color vision quiz - <AUTHOR> https://www.igame.com/eye-test/

<comment><USER2> Could also be called _display quality quiz_

<comment><USER3> Indeed, I get around 15 every time on one of my displays and just got 25 on the other one without a problem

</comment></comment><comment><USER4> 30 and 1 error, that last one of all purple I just couldn't find it.

I'd bet that monitor panel quality might a big difference.

Edit: Of course, the end text was funny because it said I could spot a mosquito a mile away, which I think has nothing to do with my color accuracy. I wear prescription glasses.

</comment><comment><USER5> I got 23.

I know I'm a typical "partially color blind" male, e.g. I always fail those tests where they show you an image made of a bunch of colored dots and ask what number you see, but on this test, I found I could find the outlier much more easily by using my peripheral vision: staring directly at it the grid, all the squares would look the same, but by looking to the side and sort of scanning with the edge of my vision, one would suddenly jump out...

<comment><USER6> 27 here ("Wow, you have excellent colour vision.") with fairly typical red/green colorblindness. I also fail the the Ishihara plate (dots) test like clockwork.

Does this test different hues (or brightness even?) of the same color rather than the red/green blue/purple of the dots? (Can't tell myself, am after all colorblind.)

This test seems to be about something else rather than traditional colorblindedness.

</comment></comment><comment><USER7> 17-20 depending on the colors. A lot of them were immediate but the dark blue/purples were difficult.

Was it just me or were all of them lighter? Were there any where the color was darker than the rest?

Just curious if that makes it more/less difficult or has any effect.

Squinting did help occasionally. As well as going with your gut usually. Fun way to spend a few minutes.

Edit: Sadly I couldn't score less than 1 since clicking the wrong color doesn't start it.

</comment><comment><USER8> Everyone should also compare monitors, browsers, and OS when saying what they got. First try: 31 / iMac 5K / Chrome. [edit: regarding browser, I don't know much about color profiling, but I do recall seeing an example of the same images being rendered in completely different colors across different browsers on the same OS. Can't find a link.]

</comment><comment><USER9> I get that the threshold for just-noticeable color difference is much lower if the tiles are touching but I found the Hermann grid illusion that arose from using spaced-out rounded squares to be very distracting.

</comment><comment><USER10> Is it a _color_ (~hue) test a lightness test? I see changes only in the later (and then it would make sense that some of my color-blind friends make reasonably high score).

</comment><comment><USER11> I don't understand the timed component. I can score 100% on this one:

[http://www.xrite.com/online-color-test- challenge](http://www.xrite.com/online-color-test-challenge)

But I ran out of time after getting 12 correct on the linked test. Edit: managed 28 after repeated attempts. I feel there is some luck of the draw here, depending upon which hues follow which previous hues, and the placement of the correct square.

</comment><comment><USER12> I scored 33.

I found squinting my eyes made it easier to spot the "blob" that had the wrong colour, and this technique made the game a lot easier.

</comment><comment><USER13> 8 then 30 so there's not much science here

</comment><comment><USER14> SCORE: 30 ERRORS: 0 Better than 90+-someodd% of the population.

I found purple hardest. I eventually failed on a purple.

Reminds me of [http://www.xrite.com/online-color-test- challenge](http://www.xrite.com/online-color-test-challenge). I believe I scored 97-percentile on that (a 3).

</comment><comment><USER15> 25 on first try. But then they go and compare my vision to a hawk, saying that I can somehow see a worm in a tree... which wouldn't have as much to do with my ability to distinguish color as it would my ability to discern detail at distance.

So I suppose a large helping of salt is required.

</comment><comment><USER16> 25\. Hawk. I felt like i was guessing on the last few but somehow they were correct.

</comment><comment><USER17> Strained my eyes doing it, had to look off into the distance for them to feel normal again! But got 31 which put me up over 95%. Think the peripheral vision trick helps in some of them.

</comment><comment><USER18> I'm partially colourblind (deuteranomaly), and stopped after I hit 30 with 0 errors. I normally do very poorly on Ishihara or Farnsworth-Munsell tests.

</comment><comment><USER19> Speaking of vision, if my finger gets slightly blurry when it's less than three inches from my face, does that mean I need glasses?

<comment><USER20> Asking on a public forum might get you somewhere but you should probably see a qualified optician. They are medical professionals that can conduct a thorough eye test.

</comment></comment><comment><USER21> 33 with 2 errors. In the last ones I was seeing optical illusions - black dots were appearing at the white intersections!

</comment><comment><USER22> This is super easy if you use Digital Color Meter on the Mac!

</comment><comment><USER23> 3\. Beat that.

<comment><USER24> Did you notice it in your daily life before this test?

I got 29 first try. But I'm sure some people get much higher.

On the other hand, my hearing isn't great though. I wonder if it's related.

<comment><USER25> Got 18 on my first try. I have trouble distinguishing red and orange, and I was unaware of it until high school. We were talking about Steve Jobs wearing the same clothes every day as a sort of uniform and I made a comment comparing that to Gilligan always wearing his signature orange shirt. At that point the whole class corrected me and said that his shirt is actually red. I still see it as orange (roughly the same as the YC logo), but I make the mental correction and call it red.

The next time it came up was when I needed a bag to carry something to work, and my wife handed me her bag. I complained that it wouldn't be manly to carry a pink bag to work and she told me that the bag was actually red. To me the bag looks the same color as the pink lemonade in this picture: [http://janeshealthykitchen.com/wp- content/uploads/2012/07/Pa...](http://janeshealthykitchen.com/wp- content/uploads/2012/07/Paleo-Pink-Lemonade-540x451.jpg)</comment></comment></comment>


Useful Marketing - what can we learn from Dannon? - <AUTHOR> http://jareks.disqourse.com/useful-marketing <comment><USER2> Years ago when I was in helping an ad-agency turn digital, myself and another hacker kept persuading management to add value in form of complementary web services (small apps that help the consumer automate or introduce information technology in the product's domain). They ran back to old school marketing during the recession, but we managed to make a few highly successful web applications that still nurture the user-brand relationship to this day.

The problem with some people in marketing is, that they view the emotional branding paradigm as an excuse for slacking on delivering real value. Their idea is, that you can completely disconnect the content from the image, and just paint pictures or write stories however poor the product design or actual communication with the user is (sometimes there's almost no communication, just top-down bombardment).

In highly successful examples this leads to focusing on joy instead of flavor (drinks), image instead of performance (cars), healthy lifestyle instead of product utility (sports apparel). However, often the product actually lacks in some way and nothing is done to compensate for it. Instead, marketers try to drive the consumption by shifting the focus from the actual product to some vaguely related subject or a fairy-tale that strikes a chord with the target audience.

To tell you the truth, I lost faith in marketing as a separate service. I just felt that products should be superbly designed, so as to market themselves or allow marketing to focus on the actual features of the product. In software, that's stupid-simple. The product _is_ the useful set of features. No need to add value in form of vaguely related useful attachments. I think Evernote is doing a great job at this.

I do understand that some product categories just can't innovate any further (most of Dannon's portfolio), so they must resort to emotional branding and adding value in form of additional useful features, collectibles, or god have mercy on their poor souls, gamification. I'm just glad software doesn't have that problem. We can just keep innovating and improving our product in tact with all the new disruptive technologies and methodologies, adding value with product design at the core, not by adding flourishes and perks.</comment>


Ask HN: How to transform a website to an app and use native phone GPS? - <AUTHOR> Expert Question:
I have a Website with a Map based on leaflet. Website also hase a Login and is based on Drupal. Map uses Geolocation by leaflet.
Not all Browsers and not all Phones support Browser Geolocation. For example iOS/Safari.
How can i make sure that geolocation work in all browsers?
I thought about this:
1) i put the whole website into an app container like provided by ionic
2) i use the native geolocation Feature from ionic and hand it over to my website running inside that container
3) i am done and this works on all devices.
Could that be possible? How to do this?! Any tuts/ideas?!
Thanks! <comment><USER2> Might check out Cordova

[http://www.telerik.com/blogs/using-existing-backend- services...](http://www.telerik.com/blogs/using-existing-backend-services-in- phonegap-cordova-applications)</comment>


ITunes Tiered Pricing Goes Live - <AUTHOR> http://www.wired.com/techbiz/media/news/2009/04/reuters_us_apple_itunes?mbid=geeksugar <comment><USER2> I'll be curious to see what happens in about 6 months. What percentage of songs will be $1.29, what percentage will still be $0.00, and what percentage will be $0.69?

Not to be pessimistic, but I suspect $1.29 songs won't decrease in price as they age.</comment>


Difference between data structure and ADT? - <AUTHOR>

I was reading my semester book fro data structures and algorithms.I am confused between adt and data structure.what is the exact difference between them? + can anyone give explain it with a suitable example? <comment><USER2> An abstract data type is the specification of an interface; it's a set of operations whose behavior is defined.

A data structure describes how data is organized in memory.

Let's imagine a stack ADT with two operations: push and pop. We can decide to implement this ADT using, say, an array or a linked list. In either case, its operation will be the same (that is, you'll get the same results; but its time and space properties may be different).

<comment><AUTHOR> does that mean in an adt the implementation is important and the the realization is hidden and in data structure the result as well as how it is obtained is important.?

<comment><USER2> You seem to imply that abstract data types and data structures are in some way similar (or related). It's not the case; an ADT is not a kind of, nor an alternative to, a data structure (and vice versa). They are different things for different purposes, just like an algorithm isn't the same thing as a data structure.

I acknowledge that their names can be confusing (both contain the word "data"). "data structure" isn't a bad name; we understand that it's about how data is organized. But "abstract data type" is less clear, indeed.

edit: I think I found what may confuse you: I guess it's a visualization problem. When you're visualizing a data structure, it probably looks like boxes connected to each other with arcs. And I think your book has nice pictures for ADTs, too (stacks, queues, etc. drawn using boxes and maybe arcs as well). Whereas it's clear that an algorithm is very different from a data structure because it's described using pseudo-code. Forget the graphical representation for ADTs; think of them instead as a list of "rules" of the form "when I dequeue something from a queue, I get the last item that was enqueued".</comment></comment></comment>


Sponge can soak up and release spilled oil hundreds of times - <AUTHOR> https://www.newscientist.com/article/2123391-sponge-can-soak-up-and-release-spilled-oil-hundreds-of-times/ <comment><AUTHOR> Now they have to make it cheap. Unless the manufacturers are able to create this product in a way that is cheaper for oil companies than what they are currently doing to clean up spills, this will unfortunately probably not matter. Hopefully they can because it looks quite impressive.</comment>


Terralliance: Kleiner Perkins' Biggest Investment Ever? - <AUTHOR> http://money.cnn.com/2010/03/26/news/companies/terralliance_tech_full.fortune/index.htm

<comment><USER2> Jeez! I would love to see that power-point deck</comment>


Super Hexagon Bot - <AUTHOR> http://crackedopenmind.com/portfolio/super-hexagon-bot/ <comment><USER2> This is awesome. I used SimpleCV in Python to detect the walls, much like you did. But I used it to transform the screen to make the platforms fall vertically:

[https://github.com/shaunlebron/super-hexagon- unwrapper](https://github.com/shaunlebron/super-hexagon-unwrapper)

<comment><USER3> An amazing concept, excellently executed. You just changed how I think about this game.

<comment><USER2> Thanks, I'm glad it changed your view of the game. My goal was to show this beautiful isomorphism between the two representations.

</comment></comment></comment><comment><USER4> For anyone interested in alternate bot approaches:

While the author made this "pixel bot" to pair their Super Hexagon with ambitions to learn OpenCV, pixel bots are almost always inferior to memory- based bots. As mentioned elsewhere in these comments, code injection should use caves and jumps, not overwrite existing code.

With a memory-based bot you often do not even need to write to the game's memory. You can use the ReadProcessMemory API call for data gathering and perform inputs with SendInput (emulate keyboard input with LLKHF_INJECTED set) or PostMessage (no LLKHF_INJECTED, also works in backgrounded windows).

The disadvantage to memory bots is that they're often more complicated at scale (beyond the point where a pixel bot would likely fail entirely), particularly with games which are updated. In cases where a game client is updated, signatures similar to virus definitions can be provided to find the particular memory address of a sought value regardless of version. By scanning the application's source code for a unique bytecode pattern known to contain the target address, you can then extract the address and read the value. This is commonly known as signature or pattern scanning.

There is another variant of bots for client/server programs where a "headless" (no display) client can interact with the server via network communication alone. Not as much fun to watch but also a very effective way of interacting with games, though it does not apply to standalone clients like this one.

<comment><USER5> Interesting. Do you have any more resources about how these bots are made? ²

<comment><USER4> I don't have any resources in particular but I've personally made them for years. In general you read memory and take action (via keyboard input) based upon what you read from memory.

For example in a game where you fish, you would wait until a fish is on hook by watching the representative value in memory and pressing a key to catch a fish when that value indicates you have a fish on-hook.

In Super Hexagon you would watch the values indicating where walls were placed, which is likely an array of enumerable values indicating a shape (each shape has at least one opening). So a 1 might indicate a wall only at north, a 3 might indicate every odd side of the hexagon is a wall which must be avoided, etc.

Finding values is obviously easier when the value is displayed on-screen, like ammo in first-person shooters. It takes some time to become familiar with exploring memory like this and you certainly wouldn't want to write your own memory scanning primitives to do it, start with a tool like Cheat Engine ([http://www.cheatengine.org/](http://www.cheatengine.org/)), ArtMoney ([http://www.artmoney.ru/](http://www.artmoney.ru/)), or one of the many other memory editors available ([https://www.google.com/search?q=memory+editor](https://www.google.com/search?q=memory+editor)).

If you'd like more details please be specific about what you'd like explained!

<comment><USER5> Thank you!

</comment></comment></comment></comment><comment><USER6> Ever since my 8-year old son beat the game multiple times on level 6, I have been working on getting there as well. The best I have made has been 19 seconds on level 6 - though I have beat the first five levels, level 6 is truly insane.

Watching my son play is quite the experience. It seems my reflexes are not what they once were. It's an amazing game.

I want to think that writing my own bot would count as beating the game, but I doubt my son would say it counts. So, here's to the next few thousand attempts at level 6. "Again!"

<comment><USER7> I got pretty good at Super Hexagon and can beat all 6 levels, but on their hard mode's I can't get very far on levels 5 & 6.

I think my level 1 record is somewhere near 10 minutes now.

<comment><USER8> What's this "hard mode" you speak of? As far as I know, there are only 6 levels, the hardest being "hexagonest" in hyper mode, which is the "hardestestest" level. I'm playing it on PC via steam.

I've beaten that but I'm keen for a harder challenge!

<comment><USER9> I would assume by "hard mode" they meant the last 3 difficulties you unlock by beating the first 3. And the challenge at that point is chasing even higher times and doing leaderboard chasing (though good luck cracking the top 200 at this point, my 250+ is only 317th last I looked).

</comment></comment></comment></comment><comment><USER10> For anyone who hasn't tried this game, it's pretty awesome! I was one of the top players on one of the level back then ([http://www.twitch.tv/david_u/c/1985844](http://www.twitch.tv/david_u/c/1985844)).

I guess OP could have just done pattern recognition since there are not so many patterns in the end.

Also I'm impressed, here: [https://www.youtube.com/watch?v=OyVcokAUj3E](https://www.youtube.com/watch?v=OyVcokAUj3E) at 0:14 you can see that the screen is suddenly rotating. This is a super hard moment to pass and I can see that as a very disturbing thing for a bot as well.

</comment><comment><USER11> (I initially posted this on the Reddit thread yesterday, but I thought I'd repeat it here since there are many programmer types who might attempt this here.)

From the article:

> Of course, because we replaced the function with our own, we have to > actually swap the buffers by explicitly calling the original > glutSwapBuffer() function. I did this by undoing the hook, calling the > original function and hooking it again.

Background qualification: I do this sort of debug launcher + DLL injection thing a lot. For one example with source, see my tool header magic ( [http://www.romhacking.net/utilities/796/](http://www.romhacking.net/utilities/796/) )

As someone with experience, please take it from me: this is a really bad idea. If you rewrite functions to call the originals, it becomes possible for another thread to call that function in the middle of your rewrite, and end up executing illegal instructions. Not only is this theoretically possible, it routinely happens all the time. Even when you think for sure that your program is not multi-threaded. Even something like hooking a Windows file size function, you'll learn that the open file dialog on Windows Vista+ is threaded, and will bomb out on you with alarming frequency.

The proper way to do this is to create "trampolines" instead. The idea is that you copy the first few instructions from the original routine, and put them somewhere else. And at the end, you jump back into the original function after your patched jump. The address of where you put the original instructions is your pointer to the "original function" that you can use if you want.

So basically, something like this:

        originalFunction:
          opcode1
          opcode2
          opcode3

Becomes:

        originalFunction:
          jmp detourFunction
          nop <padding>
        resumeAddress:
          opcode3

        trampolineFunction:
          opcode1
          opcode2
          jmp resumeAddress

        detourFunction:
          <do your function hooking magic here; modify arguments; whatever>
          call trampolineFunction <only if you want to>
          <do whatever you want with the results from the original function call>

Now, I know this sounds horrifyingly complicated: you probably think you'll need a full-on x86/amd64 disassembler+assembler. And it's theoretically possible to make a near-impossible function to trampoline. But keep in mind that 99% of APIs are built in higher level languages, and as such, have very consistent function prologues (usually saving the stack frame.) So in practice, you can write trampoline installers using one or two "signatures" and hook nearly every function you'd ever want to.

But if that seems too challenging, there is also a library called Detours ( [http://research.microsoft.com/en- us/projects/detours/](http://research.microsoft.com/en-us/projects/detours/) ) that you could try instead. I didn't find it necessary for my own purposes.

<comment><USER12> Minihook is a great minimalistic opensource alternative if you cant pay 10000$ for Detours. [http://www.codeproject.com/Articles/44326/MinHook-The- Minima...](http://www.codeproject.com/Articles/44326/MinHook-The-Minimalistic- x-x-API-Hooking-Libra)

<comment><USER11> Detours really costs $10,000??? Unbelievable. I hadn't even looked into it. Thanks for the alternative suggestion!

<comment> mh- $9,999.95, apparently..

[http://www.microsoftstore.com/store/msusa/en_US/pdp/Microsof...](http://www.microsoftstore.com/store/msusa/en_US/pdp/Microsoft- Research-Detours-v3-Professional/productID.253663300)

</comment></comment></comment></comment><comment><USER13> Oh man, I __suck __so badly playing this game, but I absolutely love the sound track:

[http://chipzel.co.uk/album/super-hexagon- ep](http://chipzel.co.uk/album/super-hexagon-ep)

<comment><USER14> Fantastic, thanks!

I wonder, is there a name for this genre?

<comment><USER15> Chiptune

</comment></comment></comment><comment><USER16> Hmm, I'm a bit surprised that some sort of ad-hoc AI is used, instead of extracting the topology of the level and running a pathfinding algorithm on it.

Once you remove all the human-confusing effects, the levels are actually very simple, being just 4-6 columns. Since the minimum thickness of obstacles is quite high and they are aligned with each other, you could even represent the level as a graph, and run your pathfinding without having to manage the geometry explicitly.

But then again, I'm the guy who thought about implementing a bot when the game came out, instead of actually doing it.

<comment><USER17> Yeah much of the game is based on human perception. All the rotation moves both level _and_ human, the walls don't ever rotate relative to the player.

</comment></comment><comment><USER18> I'd love to see the code.

I attempted the same thing[1] but between the fact that I had no idea what I was doing and having to screencap every frame (instead of hooking directly into the game's buffer), it didn't work too well. I think at best it tended to last about 10 seconds on level 1.

[1] [https://github.com/david-crespo/py-super- hexagon](https://github.com/david-crespo/py-super-hexagon)

</comment><comment><USER19> Not having managed to get past 30 sec on level 6, I applaud this bot. Using DLL injection was a very good idea too, but I wish the algorithm could play the post-finish level for a bit longer.</comment>


Couchbase 2011 - Year in Review - <AUTHOR> http://blog.couchbase.com/couchbase-2011-year-review

<comment><USER2> > Not everything went as we hoped or expected, however. Unfortunately, we > confused the heck out of many of our potential users. In addition to Membase > Server and our new mobile products we also offered Couchbase Single Server > which was a packaged "distribution" of Apache CouchDB. On top of that we > began releasing developer previews of Couchbase Server 2.0, which > incorporated CouchDB technology into Membase Server – but this product was > not compatible with Couchbase Single Server (or CouchDB). If you are > confused just reading this you get the point – and so do we.

 _Finally_ [1]

While the confusion started a long time ago [2], I would have thought that after the merge things would get simpler for the end users. But it took them another round of clearly spelled out messages from the community ([3], [4], [5]) to finally come out with a unified positioning.

Couchbase stepping away from offering a commercial version of CouchDB will allow others (probably Cloudant) to address any market needs. That's not to say that CouchDB needs the backing of a commercial entity, but sometimes having one helps with adoption in the "enterprisey" space.

[1]: This time used in the complete opposite sense of DaringFireball's usage of the word

[2]: [http://nosql.mypopescu.com/post/1200041111/couchdb- revisited...](http://nosql.mypopescu.com/post/1200041111/couchdb-revisited- message-and-why-couchone)

[3]: [http://till.klampaeckel.de/blog/archives/174-Quo- vadis,-Couc...](http://till.klampaeckel.de/blog/archives/174-Quo- vadis,-CouchDB.html)

[4]: [http://nosql.mypopescu.com/post/12237740756/what-happened- to...](http://nosql.mypopescu.com/post/12237740756/what-happened-to-couchdbs- popularity)

[5]: [http://nosql.mypopescu.com/post/13569312049/couchdb-saga- clo...](http://nosql.mypopescu.com/post/13569312049/couchdb-saga-cloudant-and- couchbase)

</comment><comment><USER3> It looks like the commercial version of CouchDB is being discontinued.</comment>


Introducing Phusion Passenger 5 beta 1, codename "Raptor" - <AUTHOR> http://blog.phusion.nl/2014/11/25/introducing-phusion-passenger-5-beta-1-codename-raptor/ <comment><USER2> As a happy and satisfied Passenger Enterprise user, I'd say that Passenger does deserve a better attention from ruby community. Just because it's (too) easy to use, doesn't mean it can't perform well.

We still use version 4 and benchmark it with unicorn and the likes, and we found no noticeable different on performance, except the fact that it's easier to configure and manage.

</comment><comment><USER3> We've been using Passenger at RailsMachine.com since they released it, and have always been impressed with the team and the performance of the product (across hundreds of customer applications on thousands of app servers) over the years.

I had been following Raptor and actually had no idea it was by the Phusion folks. Guess I didn't pay close enough attention! Very excited to test the betas and see how it performs across our network.

In benchmarks with customer's systems against Passenger4, Puma, and Unicorn, we have not seen anything that would suggest a general-case migration to any of those would be advisable for apps without a specific workload reason.

We have a number of folks on the Enterprise product, primarily for zero downtime restarts. I think "Immutable Infrastructure" plus load balancer support would negate the need for this, if you've got the orchestration in place. I'm curious how Phusion responds to that becoming more and more popular/prevalent.

</comment><comment><USER4> I just installed this to our test server and impressed by results actually

We had 100 req/sec on our 2gb test server.

We got 170 req/sec without any tuning by using the same config

Im sure i can tune it little more to get it to 200 req/sec, which is a lot improvement to previous version. Well done guys!

</comment><comment><USER5> I'm a little disappointed. Not that it was a marketing stunt, that was clear from the outset, and it worked well.

I'm disappointed they're dropping the Raptor name, it just sounds so much better than "Phusion Passenger".

</comment><comment><USER6> I am glad this wasn't just a vapourware. Given that it's an improved Passenger, I can believe all the hype.

[edit] Actually trying it out on my dev machine right now. I am getting a random error that I normally don't get with thin server. Doesn't play well with pry either right now. I'll wait a bit until it goes out of beta.

<comment><USER7> Passenger does not "play well" with vanilla Pry at all. This is simply the result of the way that it works. I would recommend using pry-remote [0] if your app is running inside of Passenger.

[0] [http://rubygems.org/gems/pry-remote](http://rubygems.org/gems/pry-remote)

</comment></comment><comment><USER8> I'm always disappointed when an open source-ish tool has to market itself. Unicorn didn't market itself. Its users marketed Unicorn because it worked/works so well.

I also don't think the comparisons Raptor is doing are fair. You're comparing an application server with a cache against just application servers. Also, I would expect Raptor's memory usage to be higher once that cache starts to fill up, or maybe you've created a super small cache just for "Hello World" apps.

People aren't avoiding Passenger because "it's too easy to use", a lot of people avoid Passenger because you're a weird company. Application servers are very important, perhaps too important to be tied to a commercial entity.

I applaud you on the work (code-wise) you've put into this and I hope the entire Ruby community as a whole benefits from it, like you claim we have with older versions of Passenger (which kinda seems like revisionist history to me, but oh well).

<comment><USER9> > Unicorn didn't market itself.

You don't remember "I love Unicorn because it's UNIX?" [http://tomayko.com/writings/unicorn-is- unix](http://tomayko.com/writings/unicorn-is-unix) as well as GitHub's postings about using Unicorn?

I admit this particular campaign makes me a bit... unhappy. But every open source project does marketing, explicit or implicit.

<comment><USER8> Was Ryan Tomayko involved in Unicorn? My point was that it would be different if Eric Wong wrote a post like that. Ryan Tomayko taking the time to write that post is exactly my point: good tools spread by having users that love them.

<comment><USER10> I think that's why he mentioned "implicit" marketing. In this day we're often fond of saying "the best products market themselves" but that usually means through evangelism via it's users.

</comment></comment></comment></comment><comment><USER11> Does Passenger 5 support hot reloading? This was the reason I switched to Unicorn a few years ago.

<comment><USER12> They support phased restart, more in line with how puma does a full reload. This is more useful IMO, provided you have multi threading enabled. With pure process concurrency you have a higher memory overhead though, as the master doesn't preload the app before forking, preventing copy on write savings.

</comment></comment><comment><USER13> What I liked about Passenger from the get-go is that it figures out how many instances to keep active, given some initial parameters and how much traffic you're getting. That is _so_ much more right than what others were doing back then, which was just starting N instances and hoping N was a good number.

</comment><comment><USER14> I'm really disappointed zero downtime restarts are still an enterprise only feature.

I absolutely cannot justify spending $30/server month on passenger - that's more than the boxes I'm running it on cost - and zero downtime restarts are a must-have for me.

<comment><USER15> If you are on a tight budget then maybe you are eligible for the startup discount. Phusion offers this discount as a genuine effort to help cash- strapped startups and students. The Phusion Passenger website has more info.

</comment></comment><comment><USER16> ah-ha! it was Phusion all along. very clever marketing efforts. I wish they could have traded on just the facts, but it's clear they got more buzz taking this path.

Kudos to them!

</comment><comment><USER17> How much of an improvement is Passenger 5 over Version 4?

<comment><USER15> A lot.

It's much faster. Learn more at [http://www.rubyraptor.org/](http://www.rubyraptor.org/) and [http://www.rubyraptor.org/how-we-made-raptor-up- to-4x-faster...](http://www.rubyraptor.org/how-we-made-raptor-up-to-4x-faster- than-unicorn-and-up-to-2x-faster-than-puma-torquebox/)

It has better tooling for helping you to identify and solve problems.

</comment></comment><comment><USER18> I thought the marketing campaign was clever. Trying to give it a try and can't seem to find the gem name and example Procfile configuration.

<comment><USER15> Gem name is 'passenger'. See the documentation for installation instructions.

Example Procfile configuration: [https://github.com/phusion/passenger-ruby- heroku-demo](https://github.com/phusion/passenger-ruby-heroku-demo). Note that the demo locks down to Phusion Passenger 4 by default. If you want to try 5, don't forget to bump the version number in the Gemfile.</comment></comment>


Unsubscribe from junk email - <AUTHOR> https://unsubscribefrom.com/ <comment><USER2> How is this different from opening these emails and clicking unsubscribe ? Or, in case such option is not available or keep sending, marking it as spam ?

<comment><USER3> convenience.</comment></comment>


Xiaomi Mi Air 13.3in Notebook Review - <AUTHOR> http://www.notebookcheck.net/Xiaomi-Mi-Air-13-3-inch-Notebook-Review.180561.0.html <comment><USER2> Reading this on mine right now!

The good:

\- Cheap as anything!

\- Internal build quality seems decent.

\- Decent screen for the money.

\- Keyboard is nice.

\- Touchpad is better than most Dell, HP etc... laptops I've tried, not as nice as a Macbook though.

\- Runs well, very snappy, I boot to to my linux (Solus) desktop in about 2.5 seconds on average with full disk encryption (excluding me entering the password).

\- Very standard hardware, Intel everything pretty much except the additional nvidia graphics card I'm yet to get working in Linux

The bad:

\- The aluminium used compared to say the base model Macbook is crap, the slightest thing and it scratches / gets dirty.

\- You cant upgrade the RAM.

\- It's heavy, it's a lot thicker than the Macbook.

\- Two annoying linux problems (regardless of distro, kernel):

1\. Switching between integrated intel graphics to nvidia is a pain in the ass, even with bumblebee it's awful.

2\. Wifi, looks like it doesn't work, but it does! Just keep enabling it in network-manager it'll take like 5-10 times and then it'll be on and fine.

Otherwise everything in linux such as sound, nvme, trim, etc... all works perfectly.

<comment><USER3> _2\. Wifi, looks like it doesn 't work, but it does! Just keep enabling it in network-manager it'll take like 5-10 times and then it'll be on and fine._

I would say that's a show stopper, especially since the machine does not come with an ethernet port.

<comment><USER2> not really, you just click the button 5 or so times after first boot and it works.

usb-c hubs and ethernet adapters are everywhere and all 3 of mine work perfectly.

If anything, the annoying as !@#$$ nvidia optimus switching that I still haven't got working on ANY distro is a show stopper / waste.

</comment></comment></comment><comment><USER4> Looks interesting. I have a Dell Latitude E6320 (my second one because they're great). Here are the features that are cool in my opinion:

* SIM card slot for 3G (remove battery to place and forget).

* Magnesium & aluminum.

* Very good plastics for keyboard (short travel for digits, springy, dense, slightly concave).

* 180° opening (you can set it flat, _very_ practical).

* HDD removable without opening the case. 4 small screws and the HDD is free, you just have to pull it to disconnect. Very useful. You just plug it back and screw.

* DVD drive removable without screws. You just press a mechanism and pull the drive from the laptop.

* SD reader.

* Ability to pop out the keyboard without opening the case, for cleaning.

* Hardware switch to kill wireless card (because turning it off and back on again is just one of those things you'll still have in flying cars).

* Can install a 'double battery' instead of the normal one.

* It's 13.3". This size is _great_. It's not a 12", which I find small and it's not a 14" which I find big (my laptop goes with me everywhere in all positions).

I find these features _very_ desirable, hence my reluctance to buy other laptops (can't use Lenovo / Dell Inspiron / HP Pavillion to save my life.). I haven't checked their XPS series yet.

<comment><USER5> I find the business machines in today's market far above any consumer devices including the MacBook (Pro) in durability, reliability, expandability, etc.

I have a ThinkPad and haven't found the need to switch to something with a poor quality hinge (e.g. MBP), poor quality keyboard (in my opinion almost everything except a ThinkPad), poor expandability (again almost every non- business machine), etc.

<comment><USER4> People who work in auto shops love the ThinkPad to the point it's probably the only model they buy. It's the AK-47 of laptops.

It apears there's little dogfooding in products, whether laptops or cars. Design flaws that just nag you right from the first use that make you wonder if people who work at laptop or car manufacturers use laptops and drive cars.

</comment></comment></comment><comment><USER6> Curiously, can I run Linux/*nix on it?

<comment><USER7> That's what I want to know as well. It's kind of a non-starter for me if it doesn't run Ubuntu.

</comment></comment><comment><USER8> In China, this about half the price of a Macbook Air and a third the price of a Macbook Pro (or something like that - correct me.) Definitely a good deal.

<comment><USER9> Where did you see that. The only price I saw was 867 euro which is much more than I was expecting for something like this. Aren't Macbook Airs about 800 euro?

<comment><USER10> It's 4999RMB on JD and Taobao, which is 737USD or 677EUR.

<comment><USER11> What about warranty , where is a good place to buy with a reliable warranty , for someone out of china?

</comment></comment></comment></comment><comment><USER12> I was just thinking this morning how my ideal laptop would be an exact replica of my Macbook Pro 13, but with a sensible keyboard and Windows 10.

This gets so close. It even has a real honest to jeebus Delete key. But then it punts on pageup/pagedn/home/end, leaving them as the terrible modified arrow keys that ruin Macs for me.

Fix that (and give it 32gb ram and a 1TB hard drive like a real computer) and I want one.

<comment><USER13> The ctrl key also seems in a bad place if you're the kind of person who uses keyboard shortcuts a lot e.g. ctrl-c, ctrl-x and ctrl-v will all involve significant hand movements to achieve.

<comment><USER14> Remapping CAPS LOCK as CTRL is the first thing I do when setting up a new laptop.

<comment><USER15> ME TOO. CAPS LOCK IS THE KIND OF KEY YOU REALLY ONLY NEED TO HIT ONCE EVERY TIME YOU RESTART. THE CONTROL KEY IS USED MUCH MORE FREQUENTLY.

<comment><USER16> Why do you need to hit the CapsLock key when you restart?

<comment><USER15> YOU'RE RIGHT. I SHOULD SCRIPT THAT.

</comment></comment></comment></comment></comment></comment><comment><USER17> Is anyone else irrationally worried about Chinese backdoors in this product?

<comment><USER18> You'd never know what the Chinese government is up to until we get a major Chinese wikileaks dump.

</comment></comment><comment><USER19> 8GB only is a dealbreaker. Also would have loved a Thunderbolt. Hope they sell a lot of this and release a pro version or similar

</comment><comment><USER20> As an aside, do folk run Linux on a Mac ?

<comment><USER17> Writing this reply from Kubuntu on a MBP.

<comment><USER21> Do you have any issues with battery life compared to OSX?

<comment><USER17> Yes. Battery life is about 1/4 as good as on OSX.

It also has issues waking up from sleep.

It also has issues going to sleep. I've pulled a hot laptop out of my backpack many times.

</comment></comment></comment></comment><comment><USER7> Given how satisfied I am by my other Xiaomi products, I think I will replace my Macbook Air with this.

</comment><comment><USER22> Low res screen and only 8GB of RAM, kind of a deal breaker for me.

<comment><USER23> 165 PPI is low resolution? That's almost the same as a 4K screen @ 27 inches. Would you call that low resolution? That's "retina" at a 21 inch (53 cm) viewing distance.

Once you hit "retina", increasing the resolution provides rapidly decreasing benefits.

[http://isthisretina.com/](http://isthisretina.com/)

<comment><USER15> Would you use a laser printer that prints at 165 PPI?

Edit: Rather than vote the question down, what's a reasonable answer? I work with text all day and would love for my display to produce text as sharp as my laser printer does.

<comment><USER23> DPI & PPI aren't directly comparable. Displays have three display elements per pixel, and printers have a considerable amount of random variation.

<comment><USER15> They aren't directly comparable, but they are comparable. A 500 DPI printer is going to produce better text on an A4 page than a 1 PPI A4 sized display, right?

Do you think text on your 165 PPI display is as sharp as even a low end laser printer?

<comment><USER23> My 175 PPI screen is sharper than a 300 DPI laser printer, and way sharper than 300 DPI ink jet printer.

<comment><USER15> The display I'm looking at now 163 PPI and I wish it were sharper.

My phone is 424 PPI and that feels about right to me.</comment></comment></comment></comment></comment></comment></comment>


Engineer Proposes Google Glass App to Make Wheelchairs Eye-Controlled - <AUTHOR> http://bostinno.com/2013/03/13/google-glass-app-to-make-wheelchairs-eye-controlled-proposed-by-engineer/

<comment><USER2> Except, the Glass UI isn't an overlay over your entire field of vision as this mockup shows.

<comment><USER3> Also, it doesn't have eye tracking.

<comment><USER4> The article cites a Google patent[1] for eye tracking within a wearable computing device. Hopefully it's still coming down the pipeline for Glass at some point.

[1] <http://www.google.com/patents/US8235529>

</comment></comment></comment><comment><USER5> This should be tested by Stephen Hawking first.</comment>


Different Color Picker for MacOS - <AUTHOR> https://itunes.apple.com/us/app/pikka/id1195076754?ls=1&mt=12 <comment><AUTHOR> There's loads of nice color pickers for the Mac. But Pikka not only looks great but has a cool way of handling sets for projects too. A welcome addition to any devs color-box.</comment>


Netflix, Microsoft, and Google just quietly changed how the web works - <AUTHOR> https://theoutline.com/post/2304/netflix-microsoft-and-google-just-quietly-changed-how-the-web-works <comment><USER2> A long overdue outcome of this new W3C disaster is the realization that the consumer or the general public doesn't sit at the table when it comes to shape the Web's destiny.

Self-proclaimed "standard bodies" W3C and WHATWG have failed to address the Web's rampant problems: privacy enforcement standards (or lack thereof), and oligopolistic or even monopolistic concentration of large parts of the web infrastructure in the hands of Google, Facebook, Cloudflare, and very few others, with a lack of incentive to do something about it because of W3C's and WHATWG's financial dependency on the very parties having no interest in changing the status quo.

What W3C and WHATWG do have delivered instead: DRM, and privacy-invading de- facto requirement of JavaScript for even the simplest of interactivity features, and WASM (even more privacy-invading, procedural features, from the guys that brought you JavaScript).

<comment><USER3> It's almost as if consumers need collective bargaining power, like a union.

Asymmetrical negotiations in all aspects of society produce asymmetrical outcomes.

<comment><USER4> You can vote with your wallet. But most won't, because when push comes to shove it's more important to have access to shows than to care how they get to you.

</comment></comment></comment><comment><USER5> What makes me most angry about all this is that the conflict is framed as being between "consumers" or "users" the anonymous masses expected to just passively download and experience "the content" and the "producers" the real contributors who fill their browsers with this oh so valuable "content".

But that is not what the web should be about at all! Yes in any social gatherings there will be a large corpus of passive participants but we should never just bifurcate the community into consumers and producers because of that. Between the active and passive participants there's a large space of interesting levels of participation, the commentators, remixers, transducers, the ones keeping quiet until they don't and and so forth.

The web should be about this large interactive space where people can exchange and collaborate in any chosen capacity. Not a distribution infrastructure of "content".

So please forget any arguments about what "consumers want to consume" it just promotes this unproductive bifurcation.

</comment><comment><USER6> Good write-up article. Also note:

"Before the EFF quit, the organization offered a compromise that would have forced rights holders to sign a covenant saying they would not use copyright law to sue people who interacted with their soon-to-be standardized DRM in the course of doing security research or accessibility work. "

</comment><comment><USER7> W3C was always going to do this.

Nothing called a "consortium" will ever have the general populace's best interests in mind.

And there's no opposing force that could leverage a penalty of any merit.

So they can just do what they like and will earn themselves or their host companies the most money.

</comment><comment><USER8> For a critical article, the headline page oddly parrots the DRM proponents agenda: "At issue was how to support copyright-protected video in web browsers". Copyright protection is of course independent of DRM, and it would be arguably better for web content (video included) if big media would't buy itself these kinds of browser features.

<comment><USER9> What other methods are there for enforcing copyright protection?

<comment><USER8> Same methods that are there for enforcing other laws of course. We had a functional copyright system long before DRM.

</comment></comment></comment><comment><USER10> In my country DRM is a way for the copyright holder to communicate to the user that private copying is prohibited. All DRM systems can be trivially broken but it is illegal. If the content is not DRM protected you can legally make private copies.

Thus the major differences between DRM and DRM-free products are:

1) The DRM-free product you own for the rest of your life. You can legally do format conversions for future proofing your ownership.

2) The DRM product you can use for a time which is usually less than your lifetime. Sometimes the physical product format deteoriates (e.g. DVD) or the file cannot be used anymore (e.g. if Audible shuts down its login servers).

In the case of a streaming provider I do not understand why to go through so much hassle to prohibit private copying. You could just include a text that says "private copying prohibited". This would be an easier way to achieve the same thing.

I have a feeling that there are some people actively misleading copyright owners to use these DRM solutions and pay for their use. After all they only pay for delivering this message to the end user in an overly complicated manner.

</comment><comment><USER11> Nothing changed at all. W3C came up with lots of stuff that vendors chose to ignore, and vice versa. Ever since the web was remotely popular, browser vendors did their own thing.

Browser DRM is no different from <font> in that respect. The only difference here is that the W3C didn't take years to bend over, but months.

This is like a kid crying "wolf!!" in the zoo.

<comment><USER6> You can not compare the <font> tag or a technology that is convenient for Netflix's business model.

<comment><USER11> That's besides the point.

My point is OP acts as if W3C ever had any authority and the DRM affair took it away. In reality, they never had much authority.

Browser vendors will pretty much do as they please, as they always have.

<comment><USER4> Absolutely. Vendors have long looked upon W3C as providing opinions. The history of web innovation has always been one or more parties moving quickly to build something new, and W3C playing catch up to try and herd all the cats into something developers can support across as many browsers as possible.

</comment></comment></comment></comment><comment><USER12> Discussed previously:

[https://news.ycombinator.com/item?id=15278883](https://news.ycombinator.com/item?id=15278883)

</comment><comment><USER13> Anyone know the implications of EME on things like new "super cookies" or other privacy invaiding techniques?

<comment><USER14> As it stands, EME has no direct impact on privacy, but since its very nature is a binary blob explicitly outside the control of the browser or the user, one can imagine DRM being used for purposes other than it was originally conceived for. And such kind of tracking would be impossible to simply "block", without disabling the whole page/site/app, a trade-off that most people will make in a predictable manner.

DRM is just a natural consequence of commercialisation of the web and the pushes and pulls that big money brings into the picture. We won't be going back on this. The best we can hope for is govt regulation and more awareness leading to better choices from the end user, who has the power to shape the web but sadly remains distracted, diverted and ignorant, by and large.

</comment></comment><comment><USER15> If the W3C doesn't support DRM wouldn't that quickly lead to more non-W3C DRM? I don't get the big deal. Netflix would ship their own browser if they had to (and that'd be a bad thing).

<comment><USER16> _Netflix would ship their own browser ..._

They already do, it browses only Netflix, and they call it an app - at least on all non-general purpose computational devices e.g. smartphones, smart tvs etc.

</comment></comment><comment><USER17> If the closed part of EME and the remote possibility of being thrown in jail for researching such extensions was removed, would there have been such an outcry?

</comment><comment><USER18> So this is the much ballyhooed new Microsoft? Doesn't look like the Tiger's stripes have changed so much after all.

<comment><USER19> Not sure which side do you agree with but it sure seems like you just conveniently ignored that besides Mozilla, all other major browser makers Microsoft, Google and Apple are for this as well and actually already have it implemented and ready.

</comment></comment><comment><USER20> Once you accept the idea of DRM, I don't see what's wrong about standardizing it.

</comment><comment><USER21> The web was a pile of nearly nothing before corporations embraced it. You can always go back to that. Nobody's stopping you.</comment>


Show HN: Record a podcast completely in the browser - <AUTHOR> http://www.epishow.com/ <comment><USER2> Been using for awhile. Love it. Super easy to use.

</comment><comment><USER3> Neat, reminds me of [https://tryca.st](https://tryca.st)

</comment><comment><USER4> Doesnt work in iOS

<comment><USER5> Nor on Ubuntu (Chrome)

<comment><AUTHOR> ios will be an app (someday). Ubuntu we'll probably fix soon.

<comment><USER6> Yeah, I am not worried about mobile. If it works in ubuntu it will be lifesaver.

</comment></comment></comment></comment><comment><USER7> Great job, excited to use this!</comment>


ORNL invention unravels mystery of protein folding  - <AUTHOR> http://www.ornl.gov/info/press_releases/get_press_release.cfm?ReleaseNumber=mr20110914-00

<comment><USER2> URL of their paper in PLoS ONE: [http://www.plosone.org/article/info%3Adoi%2F10.1371%2Fjourna...](http://www.plosone.org/article/info%3Adoi%2F10.1371%2Fjournal.pone.0015827)

<comment><USER3> Great to see PLoS ONE getting awesome papers! Here's to opening of academia.

</comment></comment><comment><USER4> Short URL to the patent at USPTO: <http://1.usa.gov/plfTg3>

I am not a specialist in protein folding, so take it with a grain of salt, but from the figures it does not look like method predicts actual configurations decoded from experiments. Patent itself acknowledges that (5.50): "the lack of computational prediction [...] can be attributed to problems arising form calculating molecular mechanics potentials (force-fields)".

Could anybody knowledgeable make an assessment how important this invention is?

<comment><USER5> I'm no expert, but I have explored his problem in the past as I understand that protein folding simulations are considered by some to be the constraint of biological life extension. Protein folding is an intractable N-body simulation problem that relies on number of different methods to approximate the 3D state of the protein throughout its folding sequence.

In reviewing the patent, it looks like this is an incremental improvement to simulation based off some findings in recent years, but does not seem to be any kind of breakthrough in understanding of proteins. Something called 'Vibration Mode' seems to be an empirical observation that explains how the internal dynamic of the protein can limit the number of future 3D states based on a previously observed folding cycle, and a model of the local energy minima and maxima.

</comment></comment><comment><USER6> Pretty low on detail, such as how dies this differ from the old method and what makes it so much more efficient exactly.

<comment><USER7> Yeah, I was expecting at least some kind of handwaving explanation.

Usually the writing of these press releases goes like this:

1\. Researcher discovers something that's pretty cool, and as the publication or patent is getting released decides to contact the institution's media department

2\. Media department, if convinced that it's interesting (or just happens to be bored) sends someone around to talk to the researcher

3\. Researcher explains what the hell the research is about to the media guy, who then goes away and writes down some of the fraction of the conversation he thought he understood. He collects a couple of quotes on the "Why this is important" bit. If the researcher is lucky, he gets a draft to correct before it goes out.

Judging by this particular press release, I can only assume that the guy the media department sent around to the researcher's office didn't understand a word of what the researcher was trying to say.

</comment></comment><comment><USER8> Why is there a patent on an algorithm that was developed using tax-payer money? Or maybe more importantly, why is it "available for licensing". Technically, I already own a small portion of the technique!

<comment><USER9> The Bayh-Dole Act is the reason that this can happen when the research is federally funded (in the US).

<comment><USER3> For sure - this horrible act is poison to progress in the sciences, and I believe has shown to be part of why medicine & med devices are so expensive.

</comment></comment></comment><comment><USER10> talk about deceptive titles. i know this much: protein folding is to many the holy grail of biotech. because most(?) of the most successful biologics have been large proteins. because protein folding is so obscure, manufacturing large, complex proteins is non-trivial, difficult to scale up and to troubleshoot. (using computer buzzwords since this is hn.) there are a limited number of facilities in the world that can do it right. a delicate process to say the least.

a more accurate headline might be: patent granted to ornl for work on protein folding.</comment>


Y Combinator's Clustrix rolls out databases that scale - <AUTHOR> http://venturebeat.com/2010/05/03/y-combinators-clustrix-rolls-out-databases-that-scale/ <comment><USER2> _Previously, these companies would have to pour time and resources into custom coding large databases._

No company has written their own custom database since the 60s.</comment>


Show HN: The Infinite Maze - collaborative maze drawing - <AUTHOR> http://www.theinfinitemaze.com/

<comment><USER2> Neat idea! I love how the map is user generated. You should add a point system to it somehow.

Could you point me in the right direction for beginning to create a full screen javascript webapp like that?

<comment><AUTHOR> A point system… I could add a leaderboard showing the people who have drawn the most tiles. But I worry that that would create an incentive for people to make lots of blank tiles. Do you see it differently?

As for making web apps like this- Do you want to make one with a scrollable tiled thing like this?, or something else?</comment></comment>