HNHacker News
TopNewBestAskShowJobs

tomchristie

2,252 karma · joined January 31, 2011

submissionscomments
tomchristie··on Django REST framework 3.4 Released
Closest things I know of are:

* Ruby Together - https://rubytogether.org/

* Django Fellowship Program - https://www.djangoproject.com/fundraising/

* Read the Docs sponsorships - http://read-the-docs.readthedocs.io/en/latest/sponsors.html

I think the business case is clear enough to make for a big project like REST framework. It's a relatively small investment per-company, but the relative payoff if we can hit a level that keeps it sustainable is huge.

tomchristie··on Django REST framework 3.4 Released
That's not currently supported. We need recurring revenue rather than one-offs, so that's what I'm pushing for right now. Out of interest, is recurring something you'd consider if there was another lower-priced individual tier added?
tomchristie··on Django REST framework 3.4 Released
As the author, yes.

The team I was previously with used Core API in some of https://www.crunchboards.com/

That's got a service-based architecture, and we were using it both on the server side (where we wrote explicit Core API schemes, rather than auto-generated) and on the client side (moving towards doing our inter-service communication using `coreapi`, rather than directly through `requests`.)

For us, the dynamic client libraries were a big win - the client code that you're working with becomes more meaningful and robust, as it's working with an application layer abstraction, rather than directly at a network layer.

tomchristie··on Twilio opens trading at $23.99 per share
I think it's neat demonstration. They've got a simple point to get across, and this is a decent enough way to make it.
tomchristie··on Web Service Efficiency at Instagram with Python
My thoughts on this:

* Let's stop talking about 'Donations' and start talking about 'Investment' - the conversation needs to be about the pay-off that businesses will get, not some altruistic "give-back"

* Make the case that collaborative investment has a great cost-reward, as the cost is spread over a bunch of companies.

* Make it clear that ecosystems that are well invested will be more competitive that those that are not. If your company has $$$ worth of engineers experienced in Django, you'd be daft not to ensure that Django remains competitive vs other frameworks.

It's an atypical pitch to make, and as with all investments it's difficult for folks to judge, because the pay-off is at a distance. I still believe it's still possible for us to change how collaboratively funded OSS is seen, once companies start to recognize well-invested ecosystems as a competitive advantage.

And yeah, this is pretty much the pitch I'm making for funding Django REST framework, where I'm currently 1/3 of the way towards being able to focus on it 100% of the time, with a full-time salary... https://fund.django-rest-framework.org/topics/funding/

tomchristie··on jQuery 3.0 Released
> useful methods such as ajax() (no, in vanilla js it's not "solved")

Right - I use jQuery because I've greater confidence that `.ajax()` will behave correctly across a wide range of browser versions, though I don't have any good evidence about using that vs vanilla `XMLHttpRequest` these days. I'd be interested to know which bits of "not solved" - which aspects in particular are not yet well supported?

tomchristie··on Ask HN: How do I deal with the first sexual harassment complaint at my startup?
* Immediate dismissal - the language isn't in any kind of gray zone - completely inappropriate. This person will damage your company if you keep them on. * Make sure they're not able to make a scene. No access to email or the premises at the point of dismissal. You don't want them causing further damage to the team. * Make it clear the issue is wholly between you and them, this is your action, decision and responsibility.
tomchristie··on Python 3 in 2016
Fair question. I can only speak from my own experience here:

Productivity, productivity, productivity.

Yes, there are faster, safer, and more modern languages out there. However Python for me still hits nails the hell out of getting stuff done, really really quickly. That applies both to the language itself, and from the standpoint of having such an extensive and mature ecosystem of packages to choose from.

tomchristie··on Atom text editor 1.4 released
> Is it better?

Absolutely, yes.

I found it a little "bouncy" on first pass. It felt like there was an edge-of-perceptible lag when updating the display in response to keypresses. I tried switching to it again recently, and that's completely gone now. I guess it's just a tad on the slow side starting up, but everything else is really great, and I'm definitely sticking with it this time.

tomchristie··on The Thucydides Trap: Are the U.S. And China Headed for War?
"For the first time ever we have something we need to protect"

Humanity has always been worth protecting.

tomchristie··on Python 3.5 and Multitasking
Anything you can share? Some good examples of networking code with async/await would be incredibly helpful. The documentation covers the primatives but I have a hard time putting it all together.
tomchristie··on Rules for Open Source Success
> It's ideologically motivated just like the GPL and does a poor job at letting anyone use their code.

Agree that it isn't a good choice if what you want is the most permissive, inclusive license.

(Completely with you there, and hadn't noticed the misjudged "with the openness, you can't beat the WTFPL" above.)

> Sure, it's a personal choice, but if you do choose it you're not doing yourself or anyone else any favors.

I wouldn't and don't use it for my projects, but I'd absolutely defend anyone else's choice to do so.

The choice to go with a license that actively eschews the standard reliance on legalese is a form of self expression. If someone chooses to use it and disregard the supposed legal risk, then I totally respect that.

tomchristie··on Rules for Open Source Success
> Please, please, please, do not use the WTFPL

I think it's a valid, personal choice.

If someone wants to make the point that they think licensing legalese sucks, and wants to license their work accordingly, then fair enough.

It's a little absurd that I shouldn't be able to, in plain words, express "This is my own work, and you can do whatever you want with it". Eg. I shouldn't need 'warranty disclaimer' to not be at risk of liability, unless I was explicitly providing some kind of guarantee in the first place. (It's just a bit of freely available software, hardly leaving a dangerous item out on the streets.)

Any legal system that leaves its citizens unable to be protected by simply using clear, plain and unambiguous language is failing in its duty to some extent, so I'm perfectly sympathetic to developers who choose "fuck that shit" as a personal preference. :)

tomchristie··on 400 days of Go
Link is "Needing an IDE should be a code smell".

Nothing controversial there.

tomchristie··on How we ended up with microservices
Indeed. But you can't guard against catastrophic system failures (out of memory, disk, processor time, corruptions) in the way you can with independant services.
tomchristie··on How we ended up with microservices
When I say 'architectural' there I mean that as in the underlying design. How the system is modeled and and what different objects and interfaces exist in that model.

Eg. Say you have a billing component in your system. You may have the same underlying billing component in either a monolith or as microservices. It may be a nicely decoupled in both cases (either existing as an independent module/library in the monolith case, or as an independent service in the microservices case.)

The (potential) benefit that's afforded from the microservices approach is not that there's a better underlying design there, but that a single team or developer can properly take ownership of deploying, scaling, monitoring and managing the service, independently of the rest of the application. (Plus scope for partitioning and graceful partial failures vs whole system failures)

tomchristie··on How we ended up with microservices
> The module will still affect everything that is dependent upon it if it is rebuilt as a microservice.

Your services are running on different servers (or containers) to each other, so they're partitioned. If one service has a bug that introduces a catastrophic error that takes all the server resources you'll either:

Monolith: Bring down the service completely. Microservices/SOA: Timeouts to part of the system, and partial loss of functionality.

(Assuming you've done a decent job of engineering for partial failure)

tomchristie··on How we ended up with microservices
The benefits of microservices aren't architectural. The point re. library APIs vs services APIs is completely correct, because that's actually not what the microservice style addresses.

The point is rather organizational/operational - Being able to independently deploy, scale, monitor and manage different parts of the system.

That allows you to distribute ownership of the system, and also allows partitioning, so that a failure in one component need not effect the whole system.

tomchristie··on High Frequency Trading Defined
I understand we can speculate that volatility could increase due to lower trading volumes, but the lower volumes aren't the only factor to take into account in this scenario.
tomchristie··on High Frequency Trading Defined
Does anyone know if regulations on minimum terms for holding period for stock ever been used/considered in modern markets? (eg. day/week/month?) I realize that it'd effect liquidity in a similar way to transactional taxes (portion of portfolio tied up in term at any given point) but could it also reduce volatility and ensure trading against long term value rather than short term artifacts?
tomchristie··on High Frequency Trading Defined
> you're obviously going to want to trade FIRST on those fundamentals .. right? Cause whoever does is going to win the day

If you're only trading long term, then sub-second differences are essentially irrelevant.

I think there's a perfectly reasonable point here. Fundamentals as "trading against the future profit of the company". HFT as "trading against the system".

tomchristie··on Better and worse ways to spot a liar
From the source: "CCE agents identified 24 times more mock passengers (66%; 60% at Month 1 and 72% at Month 6) than suspicious signs agents (3%; 6% at Month 1 and 0% at Month 6)" ... "base rates of identification of genuine travelers identified as being deceptive in the 6 months before the trial (1 in 1,247 passengers) did not differ during the trial with suspicious signs (1 in 1,219 passengers), or CCE (1 in 1,295 passengers)"

So my reading is 2/3 mock passengers identified as true positives, 1/1000 real passengers identified as false positives.

(With some provisos as noted in the paper)

tomchristie··on Better and worse ways to spot a liar
The paper itself: http://www.apa.org/pubs/journals/releases/xge-0000030.pdf
tomchristie··on GitHub Raises $250M at $2B Valuation
> There are already a number of players doing exactly what GitHub does

There are folks delivering similar services, but nothing remotely of the same standard.

> there isn't that much that ties a project to GitHub

They don't need to have any stickyness if they continue to provide a service that's far superior to other's offerings.

New entrants will find it incredibly difficult to break through at this point because of the immense investment that'd be needed to rival GitHub's service, and the lack of achieving significant user base and income during that process.

> Something tells me that the "facebook for programmers" angle is essential to selling the dream here.

The network aspect doesn't really need to be their main selling point.

GitHub's value to development companies is dead simple: It's a more productive tool than anything else out there.

tomchristie··on PostgREST – REST API from any PostgreSQL database
"The problem is scaling your database, keeping your data secure, and iterating to meet business goals with a growing codebase and infrastructure. A mess of stored procedures would restrain you from doing all three."

Perfectly expressed.

tomchristie··on Life paint
> what's the difference?

The difference is that when you're behind the wheel of a car your in charge of a machine that can very easily kill other people.

> the chance of major injuries is radically lower than when riding a bike.

The chance of causing major injuries is radically higher. You're confusing that with the chance of the driver themselves be the subject of the injuries.

Of course there's a higher degree of accountability for drivers, as there should be.

tomchristie··on Life paint
> I fall squarely in the camp that says they are just not suitable vehicles to share the road with other occupants

Here's the converse:

* Bicycles the cause of essentially 0% of road deaths.

* Motorized vehicles are the cause of essentially 100% of road deaths.

It's not the bikes that are unsafe.

tomchristie··on The I-JSON Message Format
> I-JSON doesn't appear to solve this problem

It's not within the scope of what I-JSON is intended to address. This is a more formally specified and slightly more constrained variation of the existing JSON spec. Adding new datatypes would mean that it would no longer be JSON.

tomchristie··on Django REST framework 3.1 released
Oh right, writable nested serializations, sure. I won't rehash the reasons that we don't support that in core (ill defined what behavior the user should expect) but yeah it'd still be good to have a third party package that does a decent "best effort" job of that.

My personal take on this is forget about "shitty hacks" or trying to handle this automatically, and just write the serializer create and update methods explicitly.

tomchristie··on Django REST framework 3.1 released
Well actually no, it'd be very feasible to re-write Django REST framework as a framework agnostic core. I've done a bit of exploratory work with this and there's nothing there that I think would be particularly fiddly.

The main questions would be how we'd manage support, packaging, documentation etc. Also is the benefit worth it if it means an extra level of indirection for our existing user-base? Right now focusing on Django REST framework in it's current form feels like the best effort-reward, but there's no fundamental architectural reasons stopping us from moving to a more decoupled core, with a Django specific integration layer on top of that.

← PreviousPage 2 of 5Next →