skysight-inc/HackerNews huggingface dataset:
This is a good place to start:

https://martinfowler.com/articles/microservices.html

The opening sentence sets the tone well for the article well:

"'Microservices' - yet another new term on the crowded streets of software architecture."

A colleague of mine once said that his work (he was a business strategist) was "slowly coming into focus." We're pretty far along today in our understanding of microservices, but at the time the article was written (early 2014) microservices were "slowly coming into focus". Reading what people where thinking when the industry was trying to define them should help in understanding what they are today.
It seems that the author places a lot of emphasis on the maturity and future prospects of various libraries. I'm surprised that Rust was so quickly dismissed as tokio seems to have a bright future ahead of it.

What I do think is a fair point is Rust's learning curve. With that in mind I would like to suggest a third alternative: Nim.

Support for epoll/kqueue/IOCP has been in Nim's standard library for a while now and is already very mature. The learning curve is probably somewhere between Rust and Go. In addition Nim also offers a GC that is predictable and controllable.
maybe the additional time is to serve the full page notice "DO YOU WANT TO USE THE APP"

which they insist (for me anyway) on every single page I load.
What if I don't want to quit my job?
Look into Pony's reference capabilities. To put it shortly, the compiler will guarantee that there are no data races through this system, and therefore the runtime is able to use shared memory and pointers for efficiency.
Fast reverse geocoding with offline-geocoder
Can you be more specific about what boilerplate is necessary?
what would be the most durable material to laser-engrave instead of clay?
Thanks for bringing up other frameworks in DL! Amazon's DSSTNE is restrictive, but it's great for their purposes. On the DSSTNE GitHub you can see statements like:

"DSSTNE currently only supports Fully Connected layers ..."

Kur supports the cutting edge: like CNN/RNN.

"DSSTNE Engine works with data only in NetCDF format."

Kur supports the data that you have on hand. You can see in the tutorial (http://kur.deepgram.com/tutorial.html) how easy it is to send brand new data in the familiar Python pickle object.

These are the kind of GOTCHAs that people doing deep learning run into all the time. And they are a major time suck. Kur relieves you of those duties so you can work on more interesting parts, like trying novel models :).

We're so glad DL tools are coming out. But there's still tons of progress to be made and Kur is one step along that path—making the user experience more efficient and enjoyable.
> The amount of complexity and ritual required by Rust’s ownership system is high and there is no other language I know of that is really good preparation for it.

C++ helps, if you are familiar with RAII usage in it.
I'm not sure this article is really saying too much at all. I started with extreme programming back in 99 (after following the proponents and all the heated discussions on the most brilliant OTUG email list)

Many many times I have seen this kind of question, "Aren't we just making this too complicated?"

and the response being "It's not complicated, if you misunderstand X Y or Z you are probably going wrong"

My observation is, many things of the things we leverage in the software world are answers to problems. Some of those answers seem so good, and work brilliantly when combined with other answers we package a set of answers as a "process / methodology" and advocate it.

But sometimes for some people the answers don't really match the problem, or need adapting to the problems at hand. Now, without good insight into the original problems, then YES it will be "too complicated". Any time you do things for problems you don't really have it is

A phrase that was thrown around in the early days of XP was "Brain Engaged", to try and highlight that you don't blindly do things, you need to be aware why you are doing something and adapt as necessary.

However! If someone says "hey this new new way of approaching design is awesome", and it piques your interest, You should blindly learn/try that something new and debug it till you get an understanding of why it was considered awesome. At that point you can brain engage it as needed.

So back to the original question, yes, we do make things too complicated and we shouldn't do things that don't make sense. It may not make sense because we have the knowledge and experience to know it doesn't, or it doesn't make sense because we are too inexperienced. Both are valid reasons to stop and start asking what is going wrong? why isn't this working? In the world of "Lean" this is the idea of "Stop the line", sort things out, start moving forward again, even if slowly at first.

All that doesn't mean you should keep things really basic without changing, it is very important to know how to adopt ideas for doing things better and that actually contribute to things we care about.

Also important to try not to become a cynic, eg, "tried microservices, they suck, OO sucks, imperative sucks, VB sucks, NoSQl sucks". When we become cynical of something it becomes very hard to be brain engaged in regards to them. Also the opposite is true, becoming enamoured with something can limit our brain engagement also like "Functional program all the things!, unit test all the things!, scale all the things! deep learn all the things! distribute all the things! Reactive all the things! things! the all Forth"
Why wouldn't you want that? I genuinely don't understand why you think it's bad. It seems pretty worthwhile to try and understand the design choices and tradeoffs of different platforms.
The Americans put pressure on Cuba to not admit Snowden:

"Snowden failed to board an onward flight to Cuba the next day, the paper says, again citing Russian officials, because the US put intense pressure on Cuba, warning of "adverse consequences" if Snowden were allowed to board the plane. The Cubans subsequently informed Moscow that the regular Aeroflot flight would not be permitted to land in Havana if Snowden was aboard."

http://www.csmonitor.com/World/Global-News/2013/0826/Russian...
So if you want to make big money at a startup, you have to found your own or gtfo?
Scott Eaton's Bodies in motion
College fires IT admin, loses access to Google email, sues
If a company is grossing $20MM/year and stands to improve that by more than 0.75% by having a faster site, then yes, it makes sense to spend 0.75% of your revenue to do so.
Oh yeah, Kur allows MUCH faster prototyping. And if you utilize Jinja2 (Kur supports that in the Kurfiles), you really start unlocking the time savings.
How is adding dynamic graphs to TensorFlow "after the fact" while adding it to Torch isn't? (Torch is much older than TF).
"As is routine and consistent with US regulations, persons with felony arrest warrants are subject to having their passport revoked," said Psaki. "Such a revocation does not affect citizenship status."

http://thehill.com/blogs/blog-briefing-room/news/307253-repo...
"We've already seen this happening on the HDL side of things; open-source, research-driven efforts like Clash and Chisel are orders of magnitude better than the crap that industry has been using for years (VHDL and (System) Verilog).
"

As someone in the industry, I would have to disagree. I question this every time someone claims it's so awesome. None of those solutions can run simulations on the back annotated netlist . How do you design without a simulation tool that can work at every stage of the design flow?

RTL is a behavioral model. Post synthesis is the physical model. What do you think synthesis engineers do? Just sit around watching the tools run?
From ESR's conclusion is this:

> For comparison, I switched from Rust to Go and, in the same amount of time I had spent stuggling [sic] to make even a <100 LOC partial implementation work, was able to write and test the entire exterior of an IRC server - all the socket-fu and concurrency handling - leaving only the IRC-protocol state machine to be done.

I don't think this is an unusual experience. I'd consider myself a journeyman programmer with 16 years of experience and probably a dozen languages under my belt. Learning Go was unique: after 3 days I felt productive; After 2 weeks I sort of looked around and said "is this it?" Go gets out of your way for the most part, and performs as advertised.

For a lot of programmers, for a lot of projects, that's exactly what you want.

I've attempted to learn Rust a few times, and it always feel like I'm moving uphill.

Rust is awesome for a number of problem spaces, so I'm not knocking it. And Go _isn't_ awesome in a lot of ways (vendoring, I'm looking at you). But it feels like there are a lot of core, language-level things Rust needs to improve to attract more non-genius developers.
This is the Rube Goldberg Machine of programming.
My understanding is go's interfaces is counter to OO style. It's about behavior, not objects, plus by recommending to users that you write the smallest possible interface as you can, and then compose other interfaces out of those smaller one's, you reduce the surface area of where the expression problem can come into practice!
You'll be able to easily do that once we release Kurhub.com.
You are suspicious because a tech company - which maintains the second-most-used browser in the world - wants to be more inclusive, as in, make people feel more comfortable with their products and community? That's pretty sad.
How to escape the overthinking trap: stop judging yourself
Child’s play
You could make the alternate case that people want to believe that "a calorie is a calorie" despite the evidence to the contrary because it means they don't need to change their habits. Defense against change. It's not surprising that people prefer the "science" that conveniently reinforces their life choices. The USDA and the food industry is also perfectly happy with the status-quo, because processed foods are a lot more profitable than whole foods are. In that sense, it's not surprising that people suggesting healthy foods are considered "radicals" -- people don't want to change what they eat, and the food industry doesn't want to change what they sell.
> has no good epoll/select abstraction, which is wrong

I can't reiterate this enough. Rust has one of the best abstractions I've ever used over epoll/kqueue and MS' variant, MIO. MIO has picked not the crappy POSIX select, which every major OS has a better alternative to now, but instead the OS' preferred event system. The 10 year stability requirement is awkward, as I don't think anyone can predict the future, and in 10 years, who knows what will change.

As you mention, tokio is an awesome futures based abstraction on top of that, making it a breeze to write complex, fast, event driven logic.

I'm sad that after four days he didn't like Rust, I had a 100% different experience. After one day I fell in love with nearly every aspect of the language, and it was specifically because of state machines (which they mention as one of their core desires). My biggest complaint against the language hasn't changed, which is dealing with different Error types, but even that after a lot more experience with Rust has become easier.

Anyway, for NTPSec it's sad that this didn't suit their desires, but that doesn't mean that we can't write our own.
> I didn't have enough time to get all the toolchain pieces installed and working together

You mean "babel --presets react src > out.js"?

The problem here is people keep comparing the React ecosystem to the Vue library.
It takes a fair bit of effort to call into the epoll system in a sane and safe manner from Rust. It's more than just slapping a thin "unsafe-Rust" wrapper on the C epoll API. Or at least it is in anything but, say, a toy rust-equivalent of the man-page entry examples for epoll.
Type Safe Alt-JS Language Comparison (Elm, Purescript, OCaml, Scala)
It's the libertarian right's version of "triggered"
Hard to tell. Don't know how much volume they have.

Going from a 50th site in the world in a niche topic (stack overflow) to a 27th worldwide that target all audience. It's entirely possible that it grows the traffic by 100x.

Anyway, who cares about money? 100k a year is peanuts. At this scale, if you have a solution that works well, you're good. Not even worth thinking about it.
By the time that happens, voting and elections will be the least of your concerns (as they should already be now)
> Generics are still always covariant, which has some plusses but also some real minuses.

How is this even possible? Does the compiler just fail if you try to put a type parameter in contravariant position? Or does it allow it and then blow up at run time?
Exactly. It's almost ironic that people have chosen to conflate "agile" with a highly prescriptive, heavyweight process. :-(
I'm aware of this but Alan Kay's work and this seem to be orthogonal. Alan Kay talks about reducing real systems that have compilers, inputs etc whereas Elements talks about like the day to day ways of writing code. Alan Kay might come up with a new keyword whose semantics magically lets you cut out 30% but Elements shows you that if you make your types behave certain way, generics will let you cut out a lot of code.
I think the list is about IDEs built with JavaScript, ie Node.js/Electron.
A country is hit by whistleblowers when these people find their government doing things that are against their principles. That's much harder to happen when the people employed has no such thing.
GPS is a military project controlled by the US. With just a switch of a button the civilian receivers will be practical worthless for navigation. They can't do that on Galileo or GLONASS. I imagine Russia can dial down GLONASS precision for civil use cases, too.

At least Galileo is a competitor, and the political/military discourse about it is still ongoing.

https://en.wikipedia.org/wiki/Galileo_(satellite_navigation)...
Things such as joins, transactions, and means of enforcing data integrity are useful when solving a whole slew of problems. Not to mention the tooling and community you benefit from when you use a common RDBMS.

I never found data translation/serialization to be a big pain (just rely on a framework/lib that does it for you). It's a bigger pain to hand-roll joins that would be a one-liner in SQL or deal with issues that arise from having your data (unnecessarily) reside in many systems.
No, so I may not be your target market. The only thought I usually put into something like a shirt, is I'll buy a t-shirt of a band I like, or one that has a cool logo/slogan on it, or whatever. That's about it.
I am a go fan, and when I saw this article on the fp, I said to myself "here we go again"

It's the 4th law of HN: Wherever Rust is, Go goes, and vice versa.

I am considering just accepting this reality that people will always pit these two against each other, and maybe just accept it for it's positive merits: that the extra competitiveness will help create a better ecosystem for the two of them.
Java would be disqualified due to GC:

> It is worth noting that Go came nearest disqualifying itself entirely here. If it were not possible to lock out Go’s GC in critical regions Rust would win by default.
Would you say vue.js is the next evolutionary step after jQuery?
Elasticsearch ransomware attacks now number in the thousands
See also Artifact Evaluation, a process used in several PL/SE conferences that makes evaluation of code (and datasets/studies) an explicit step in the review process:

http://evaluate.inf.usi.ch/artifacts

http://www.artifact-eval.org/
about 3 years - i think an experienced candidate could command about 140k
Why are Seattle home prices so high? The City's low rate of homes for sale
I cannot agree more with his conclusions about Rust, you can overlook a lot of problems. But the language itself is just such an arcane pain to deal with, the author really brought this out: Even just writing and printing few lines of strings out has possibly hours of gotchas in it. Add a little IO and you're looking at days.
It's not a question of a lack of documentation, I just think the language is weird. I truly wanted Rust to be great and I keep looking at it wanting it to be better but it just isn't.
Isn't it funny how in the real world, suddenly the so lauded 'type safety' really just doesn't matter that much in practice. A simpler language overall would have made a much bigger impact than any generics.
Your company does not 'promise' you compensation - they have a contract for that.

If you were to have some kind of special 'non dilution' clause in your equity position (which by the way, no founder would reasonably agree to), then you should have it in writing.

But it's moot. One or both of you was obviously struggling with how all of that worked, because giving employees anti-ratcheting clauses is not something that should really be done. In fact, it should be avoided if at all possible even with investors.
> For comparison, I switched from Rust to Go and, in the same amount of time I had spent stuggling to make even a <100 LOC partial implementation work, was able to write and test the entire exterior of an IRC server - all the socket-fu and concurrency handling - leaving only the IRC-protocol state machine to be done.

That's basically my experience with rust and go.

go is stupid, but I can write it. It's stupid needing to write the same for loop over and over again, but it's an obvious for loop that doesn't have any surprises, and everyones for loop looks the same.

rust is smart, but I can't write anything in it (yet). Some of rusts features would be nice to have in go.
"If you can't explain it simply, you don't understand it well enough."

If you can't give a single example supporting your claim, without instead resorting to confused mental gymnastics, there will be no merit to your case, however much you want it.

Share an example of where developer preference is orthogonal to developer productivity.

> saying "NFL players would be likely agree that sports cars helped their performance", is a similar way of saying the same thing, this time using NFL players and sports cars as a proxy for the same point.

Sure, and this is what a bonus is. People are given bonuses, in all fields. They wouldn't be if it didn't work.
I disagree with many points in this article, but being writing Rust in my company since summer I can definitely say it is much harder than any other language I've used. Now when I learned doing a synchronous service with it Tokio was released and I've been banging my head against the wall to get the concepts.

But then again, it just takes time. And I have some crazy two month uptimes with my rust services eating that constant 8 megabytes of ram...
yeah, thanks, I accidentally edited the phrasing from something like "don't go in the left lane" to "keep left".
Deep Learning Paper Implementations: Spatial Transformer Networks – Part II
Constructive comparisons with deep knowledge of both languages are priceless, when articles "I tried Go/Rust 1 week and didn't get it" are useless. Title "vs" often is a marker of articles of the second type - just to share emotions, not knowledge.
Is there an equivalent to numpy in the Lua space?
A University I attended had fallout shelters in at least one of its major campus libraries (also a National Archive IIRC). Might not be 'on the shelf' so to speak but I bet they might still have a copy.
Notwithstanding it hasn't been a great few years for only destroyable by hammer artefacts.
Au contraire: Go has a built-in 'select' keyword that lets you wait on a set of arbitrary (blocking) channel operations. Start up blocking I/O in goroutines, and select on channels that give you the results.
Combine that with the toxic people inhabiting every popular sub reddit, it's some place I unfortunately no longer visit.
> Generics are genuinely tricky: They allow you to write many kinds of useful functions in a type-safe manner, but every known approach for implementing them adds complexity to the language. C#, Java and Rust all bit the bullet and accepted (some) of this complexity. Maybe Go will find a sweet spot, preserving its simplicity but adding a bit of expressiveness?

I seriously doubt Go and the people who maintain it are going to do groundbreaking work in this area. It's and extremely developed area of language design (and still developing way ahead of where Go would ever go)

What "complexity" does simple parametric polymorphism (i.e. forall a) bring? The only thing I can think of is some extra syntax, which is far less complex than a codebase built upon a lack of parametricity. Hell, don't even allow user-defined parametric types and force everyone to stay with Go's parametric builtins but allow programmers to abstract over them. Seems like a no-brainer to me.
All that made them special in the first place was offline history and mobile apps for IRC. If anything, their shitty Electron desktop client is a downgrade.
That website is very heavy on JS, that's why it's unbearably slow. I remember having to use it on a mobile with 512MB of RAM once, it literally killed my browser (probably the OOM killer)
Twitter just sold its developer platform to Google
Woman Dies from Bacteria Resistant to All Antibiotics
sounds like @mbesto is referring to the changes in cap table/shareholding structure rather than the 'vibe' of the deal
> So when I see shit like this, I always wonder why is it so hard to find a design job?

Because it faster and cheaper to pay one person to do both the design and the work to make it a reality.

There is also a supply and demand issue. Too many designers, not enough front-end devs (which is why you can easily find jobs as an employee)

if you want to be a designer only, I would suggest striking out on your own and hiring out for the work you dislike.
The latest release was last month. Not that it would be concerning if it really was 5 months ago.
[EDIT]: I misread the bill, ignore this comment :)

So, the devil here is in the details: https://www.congress.gov/bill/114th-congress/house-bill/5719

The tax bill will come due when the employee leaves the company; so this doesn't really help a lot.

Has a few caveats that make it inapplicable to early employees too.

Interestingly, it seems like it applies to stock, not just options, which if it didn't come due when you left the company, would be great since it would mean that startups could stop dicking around with options for tax reasons and just issue RSUs.
TECHNOLOGY AND THE AUTO INDUSTRY: A GAME OF CATCH-UP
Sex? I'm not sure. Males tend to be both dumber and smarter: https://qph.ec.quoracdn.net/main-qimg-929b67e5b164c180d10d9e...

Race? This has been studied extensively. http://4.bp.blogspot.com/-KwMUlOoZIog/VOj9HtgsqLI/AAAAAAAAC2...
This is pretty common for a forked server model. You already need to handle the case where the worker process dies, so it's simple to also occasionally kill it on purpose. Memory thresholding is nice, but you also have things like MaxRequestsPerChild from Apache. Restarting the worker after say 100,000 requests is cheaper than profiling / tracking down slow memory leaks. OTOH, when you get down to MaxRequestsPerChild 10, you have clear problems that should be easy to track down; you can also do CPU usage thresholding to limit damage from infinite loops that are hard to reproduce.
Yep, fairly heavy user here and it's basically fine for me, probably because I'm used to it. Simplicity works. Only thing I really wish for is a proper, first class, not-electron desktop app.