1,265 karma · joined December 6, 2011
There are only 2 hard problems in programming:
1. naming things.
2. cache invalidation.
3. off by one errors.
I just found there's very little I needed them for that couldn't be resolved using a makefile or package.json scripts.
I legitimately love gulp though, because it finally let me grok streams.
Last time I spoke to people there, they were only hiring people who were local/willing to move.
I have found that taking consulting work is a good way to buffer your income for a while, until you find the position that is right for you.
I don't know if e-lance is the correct way to go about it tho, because there is an element of social branding and networking related to all of this.
You could start blogging, or do some presentations at local user groups of various techs. Writing about experiences like what you have been through can actually be very freeing.
something usually comes up.
it's a pity they couldn't make it work for them.
I would separate business logic into a single service and have all other modules call that using a standard protocol like REST or thrift or something.
The issue is that if that logic is being executed all over the system already, it's going to be difficult to break it into a separate service that doesn't do that
it all comes down to this - http://www.infoq.com/news/2015/01/microservices-sharing-code
If you have multiple components that are depending on the same code, if you try to split them into multiple services that are being independently deployed, you need to keep the code they are depending on in sync.
So making a change to the code shared by multiple services, means you have to deploy multiple services for a single change.
I completely agree with you about the protobuf/thrift angle though. If you're in that situation, you are already doing it right.
Otherwise when you eventually split them out, you will end up being in a situation where each service needs copies of all the files it required before.
This then is a situation where you will have to extract into a library, and make general enough to be used and versioned that way.
- avoid code sharing wherever possible. It creates an implicit dependency. (If you have a common library or util file, you've done it wrong. try again.)
- don't merge your trees: (ie: each component in the code should have it's own readme and tests folder.)
- write far more unit tests than functional/integration tests.
(if you separate out components later, those tests can't move with them)
- if you use an ORM or similar, you are probably going to have a very bad time about it (breaks the no-shared code rule)I think everybody agrees with that.
The issue is that architecting your system like that on a code / repo level means that you gain the complexity of having to manage dependencies between your components, and it complicates the deployment story.
microservices then further complicates things by requiring you to be able to independently deploy each service. this is a lot of complexity to manage for something that doesn't directly solve any problems in your business domain.
This reaction you are seeing is because people have now had enough time to actually work on and hear about projects that were built using microservices. Many of them have found that they don't deliver on their promises, because of the reasons mentioned in the article.
at least before chrome web-inspector got the handy checkbox.
The fact that you might need vocational training when trying to get a job that's outside your area of study surprises people ?
I just found plain server side code easier to reason about.
no more shared anything, other than the kernel.
so far they've all said yes to what I considered very high.
i've used it for things like migrating between json schemas, and even converting normal json into elasticsearch bulk imports on the fly.
- Graft [https://github.com/graftjs/graft]. Our attempt to determine what microservices taken all the way to the browser would look like. It's a higher level library built on top of jschan. The idea is to be able to use node streams interchangeably on both sides of the pipe, with the communication managed by libchan ... and work invisibly over SPDY or websockets or whatever.
Unfortunately, SPDY was replaced by http2, which meant that libchan went under construction for a bit while the library support was figured out. At the same time, io.js happened. And now there's a very fastly evolving streams spec that is feeding on the whatwg effort to standardise a stream spec for the browser and node.
I am going to take up the mantle again, but there needs to be some settling of the ecosystem first. =\
having it be that deeply associated with the other brand reduces the visibility of the project?
https://github.com/atom/electron/blob/master/docs/developmen...
Slack, Mapbox and more.