macca321

I'll take a look when I get a chance - from a glance at the Phoenix docs looks it like a railsy MVC framework though?

The pattern I'm talking about is dicussed here: https://news.ycombinator.com/item?id=2945513

Building (certain) applications using in-memory persistent objects instead of using a stateless web app + database server, somewhat similar to a multiplayer game.

Made programming fun again. Don't seem to get to use it at client sites as it's too extreme an approach :(

10x code is the code you didn't write because you knew how to solve a problem simply (usually by knowing about the existence of available tools and approaches, instead of building things from scratch),

Very cool! Lots of questions!

Could this be used for inverse kinematics?

Would this approach work in 3d?

Could you use it for reverse model binding with DOM elements?

I start making up a sci fi alien invasion story set in the local area, which quickly rambles, leading to sleep.

I wonder how hard it would be to game by taking out lots of insurance and then delaying the flight deliberately.

I guess that scam works because the cost of a delay is subjective.

The dream is that your client can dynamically update itself or seek out ways to process new, incomprehensible things* that it encounters while traversing a rest request (see "Code-on-demand in REST literature).

If you think this is possible in the wild or not is another matter.

*each nugget of data can be versioned and meaninged independently

First and foremost an API which services it's clients need well is a good API.

There are many people arguing things that aren't REST (e.g. pretty urls, media type based versioning) in the name of REST, and there are also (fewer) people trying to talk about things that are REST (e.g. HATEOAS) in the name of REST. This makes it (understandably) easy to blame REST due to the large amount of confusion.

In fact, I did a Bad Thing in my other comment by pointing out that REST-as-widely-understood isn't REST as all the mature individuals who are interested in REST APIs have taken to referring to them as Hypermedia APIs in order to avoid having to rehash the differences and kick off a flame war. I wouldn't have done it if OP hadn't mentioned HATEOAS.

There's nothing to stop someone putting resources on an api which do the one thing a client needs to do.

And what you describe nothing to do with REST, it's to do with overly fine-grained API design, without taking your users into account.

How your URLs read (and if you PUT or POST) is entirely unimportant if you are doing hypermedia/HATEAOS/REST as Fielding envisages it (http://roy.gbiv.com/untangled/2008/rest-apis-must-be-hyperte...).

"If the engine of application state (and hence the API) is not being driven by hypertext, then it cannot be RESTful and cannot be a REST API. Period."

If you're doing REST as-in JSON-over-http + a docs page, knock yourself out.

edit: Also see: http://roy.gbiv.com/untangled/2009/it-is-okay-to-use-post

What would you suggest?

public TResult SomeMethod() where TResult : (string name, int id)

I'm just going to pimp my library (github.com/mcintyre321/OneOf) which lets you pull this off in c#. I'm quite sad it's needed though, it would be great to have it in the language.

You can achieve something similar via a library: https://github.com/mcintyre321/OneOf

I also think language level support for this would be a killer feature, it turns OOP and the requirement to use polymorphism to guarantee strategy-per-type on it's head.

There's a project called Orleankka which lets you use Orleans and virtual actors with Akka style messaging:

https://github.com/OrleansContrib/Orleankka

What is this sun you speak of? /UK

A .NET take on it https://lostechies.com/jimmybogard/2015/07/02/ndc-talk-on-so...

Lots of people do exactly that (treat it like a dumb data store) and are wildly successful. Do what you want, but don't say other people shouldn't do it a different way which has been proven to work.

It may be that its easier for people to define the desired result set, then tweak the query until it gives them what they want.

I own forhipsters.com, what does that score?

I'm very interested in your learnings.

I've worked on enterprise collaboration software before, and came to the conclusions that the users will favour using the simplest thing for the task in hand (email or excel) no matter what SAAS products they have.

The trick then becomes 1. sell to management and get them to gamble on enforcing it's usage, (maybe by taking away the other tools, extensive training), or 2. have something that works at a grass roots level (e.g. dropbox being used to work around IT constraints) .

I think I may have just restated your post, oops!

I keep wondering if the future for workflow tools might be to unobtrusively monitor user interactions by hooking into the email client, and have an intelligent Clippy-like service which prompts and decorates their tools i.e. prompting to use ContractBeast if a contract is attached to an email (or in fact just doing so), and to display relevant information as and when needed. There was some CRM system extension for gmail years ago which I remember being radically successful.

Could something like that have worked out for you?

*and server in order to provide analysis, archiving etc.

Yup. It would be nice if there was some way to review the listings, and share info on the roles, but I guess it would be scuppered by the competitive nature of going for the roles.

occasionally i wonder if we are making a fundamental mistake when we replace the old code with the new. perhaps data versions should be first class concepts in our domains.

if you aren't stopping-the-world during upgrade, you need to ensure the old code and the new code both execute happily against the new schema.

its even worse if you want to be able to rollback.

and Theo.

It's only 'easier to spin up just the services you need' if you assume there is a cost to spinning up everything.

A useful term here is 'unit of deployment' I.e. a chunk of software that can be upgraded and redeployed on its own (implying versioned communication with other units and data storage).

Cloud storage was just used so I didn't have to manage backups myself.

I absolutely didn't separate command and query - the commands themselves are actions which execute against the domain model, and that domain is used to build responses.

My project is here: [Sourcery](https://github.com/mcintyre321/Sourcery) but I think a more mature project you might like to look into is [OrigioDB](http://origodb.com/).

Another thing that gets tricky is making your application deterministic - any calls to the current time, random number or guid generatiom, or to 3rd party services, have to be recorded and replayable in the correct order for when you reconstruct your application instance. This can get tricky if you refactor your application or change its logic later.

It's worth reading up on Prevalence/MemoryImage, and looking into NEventStore also.

I built an CRM/CMS application where every single controller action call is event sourced.

The whole application lives in memory as a single object aggregate, which gets rebuilt on startup. I started off with writing json to the file system, moved into compressing and appending to a log file, and moved into using Azure cloud tables.

It's awesomely fast to respond to requests (15ms), and to add new features, but you do get interesting new problems, e.g. along the way I had to:

- come up with a way of migrating events (as my storage formats changed as I improved my frameworks) - find a good way to do fast full-text-search against in memory objects as I had no SQL or ElasticSearch infrastructure (ended up using Linq against in-memory Lucene RamDirectories) - deal with concurrency issues in a fairly novel manner(as all users are acting against a single in-memory)

I'm hoping this architecture will start to become more popular - I think we are in need of a framework equivalent to Rails to take it mainstream.

What happens if you download new javascript code and use that to control your app?

I would like something like this for things placed anywhere on a screen. The use case is hitting the alt key and displaying labels with the keyboard shortcuts for buttons.