nicksellen

You can try this twitter thread from Kate Raworth https://twitter.com/KateRaworth/status/1239596817463103489

You're welcome to join our team chat and we can discuss further (send me an email, address in profile, then I can invite you).

(most relevant, but dated, PR is https://github.com/Trustroots/trustroots/pull/1086)

(I also saw your comments on https://news.ycombinator.com/item?id=23219900)

The open source bit allows the ultimate step of forking the whole project, and that is important to me to be able to do that, but it's not a trivial step at all, and a lot of the usefulness is in the name recognition and the userbase.

But really, I want to contribute to the original project, and given I am not the original developer, it still relies on the them (and any other founders) to open up contributions. Fortunately, in this case, they have :)

I'm one of the Trustroots contributors, we have an old work-in-progress pull request to import couchsurfing data (https://github.com/Trustroots/trustroots/pull/1086), but it needs some love.

As mentioned in https://news.ycombinator.com/item?id=23219760 references is coming.

The verification issue though for import is a big one, we couldn't just trust a JSON file the user has uploaded to have real references, there would be nothing stopping them writing their own glowing references.

I'm one of the Trustroots contributors, you're right about the governance topic, we have a do-ocracy approach right now (described a bit at the bottom of https://www.trustroots.org/faq/foundation). I'm actually keen to evolve this, with a more specific approach to community-governance, but this thinking and these talks take time.

I'm one of the developers working on Trustroots.

We're working on references :) I merged this PR yesterday https://github.com/Trustroots/trustroots/pull/1413, there is a bit more to work out for displaying them...

There is also a meetup feature already (see https://ideas.trustroots.org/2017/08/21/meeting-people-now-o...), it's a bit primitive right now, but it was a first iteration, and we've been discussing some next steps recently.

We are also open source! https://github.com/trustroots/ (with a node + react stack)

> This is the real issue. Governments restrict housing supply for whatever misguided reasons and prices go up, those prices make it a good place to park cash. Government should stop picking winners and losers.

Restriction of housing is not limited to Government, housing developers also do it:

"[Kate] Barker reached a similar conclusion in her interim report, where she noted that in order to maximize their profits, developers control the rate of production and ‘trickle out’ no more than 100–200 houses a year from a large development. ‘This may not be desirable from society’s point of view,’ she wrote." (from https://www.annaminton.com/bigcapital)

Personally, I trust the reasons that a Government would limit housing more than I would a for-profit company who are probably operating in the interests of investors who don't live in the affected areas.

Even more than Big Government control though, I would prefer the people that live in an area to have the biggest say into how things are run.

> the final chord tells you the key

That makes it sound like a definitive rule, but it's just a common convention.

You can extend this argument to banking though:

If the U.S. pumps an endless supply of money into Haiti, how could Haitian banks hope to compete with their loan offers?

it declares jquery as a requirement but doesn't actually use it - https://github.com/gitboard/gitboard/blob/master/src/js/comp...

> Deaths per 100,000 people is probably the wrong figure to look at to determine the safety (or lack thereof) of driving.

Kind of. It's useful to see the per distance and per population figures. You are likely to drive more when you are in the USA compared to Europe (due to the culture and bigger distances to travel) and this increases your risk.

If I was analyzing my total risk of dying in a road accident, both figures would play a part.

The political country I have citizenship in has a name, it's written on my passport - it is not "England".

Maybe you can see the problem if I explain it in this way: you can become British (meaning "UK-ish"), but you cannot become English.

Not only is it technically wrong, but it also contributes to perpetuating the dominance of England over the other parts of the UK.

I try to clear midconceptions/misunderstands of other countries when I know better, I would invite you to do the same now you know more :)

Hopefully I can soothe some your resentment of my accusation too - I have been learning about Germany and the forms it existed in before the unification of the states in 1871 - the culture goes back a lot further than this, I am currently learning German and planning an extended tour by bicycle (when I have learnt enough) so I can get more deeply into this topic.

The full name of the country is "United Kingdom of Great Britain and Northern Ireland" - calling it "Great Britain" is just wrong (it excludes Northern Ireland and all other smaller islands). You would also hope an official website can get it correct.

Although entire languages get it wrong - in German the UK is translated as "Großbritannien". Edit: they do have translation for UK ("Vereinigtes Königreich") but I've never heard it said/written yet... I think I'll start using it.

A worse version is when "England" is used to refer to the UK. It's very common, maybe less so in official contexts.

Use of ES6 classes would have been nice and I'd prefer to work with simple javascript objects to hold data vs rich model objects (http://foam-framework.github.io/foam/tutorial/2-model/).

I don't think this is the framework for me.

Congratulations for your hard work and achievements :)

I presume you know other people with your background that haven't managed to achieve this, do you have any insight into what the differences are?

Innate abilities? specific values? good luck? - I can imagine the general differences, but the specifics are really interesting to me.

I tried googling for H2 KVEngine but didn't come up with anything, did you mean http://www.h2database.com/html/mvstore.html perhaps?

How would you compare and contrast this with http://openhft.net/products/chronicle-queue/? (which I knows does a bunch more but seems like it could be used for this purpose too).

The conclusion is a lot more moderate than the title, the author actually uses dependency injection:

While DI has benefits in some circumstances, such as shown in the Copy program, I do not believe in the idea that it automatically provides benefits in all circumstances. This is why I consider that the application of DI in the wrong circumstances should be considered as being evil and not a universal panacea or silver bullet. In fact, in the wrong circumstances it could even be said that Dependency Injection breaks encapsulation. Although I have found some places in my framework where I have made use of DI because of the obvious benefits it provides, there are some places where I could use DI but have chosen not to do so.

I think using the word evil is far too dramatic, evil should mean do not ever use.

Changing the presentation often involves more than changing the CSS alone. For example, you might have a table of data that you want to change into a bootstrap .row/.col structure. The data itself has not changed, only the presentation, and this required a change of HTML.

The CSS always needs enough hooks in the HTML to do it's work, without the right hooks some things are impossible with CSS alone (or would be unnecessarily obscure/tricky/brittle).

HTML isn't a general data format in the way JSON is.

The idea was approximately that html was the data and css was the presentation. In reality they are quite connected and you have to write the html to support how it will be presented, a change to the presentation often requires a change to the data (html), and this doesn't really make sense.

I think a saner approach is to start with plain old data (e.g. some JSON) and have a function that can turn that into html/css/js. This is what react allows by using props/state as the input to the component/rendering function. It also permits you to pass complex objects as props/state but I like keeping to simple data as much as possible.