After trying many different tools and being disappointed by either bank integration or being locked into a proprietary budget format I settled on using a spreadsheet.
Artificial growth hormones may be banned, but endogenous ones[0] are unavoidable. Cow's milk evolved to make calves grow, this is not an avoidable minutia when attempting to comparatively characterize milk alternatives as stunting growth, but likely the central finding.
You didn't understand GP comment. Cow's milk is the single thing that grows calves hundreds of Kg in a few months. It has growing hormones in it, naturally.
RPC is not fundamentally different from REST. REST is a form of RPC. (/me ducks tomatoes thrown among boos and hisses from the crowd)
The difference is that the processes behind REST speak with HTTP. You're still doing a "remote procedure call"; you're asking for a remote process to execute some function on your behalf and return the result. RPCs facilitate the same exact thing. How is this a "fundamental" difference?
[I'm speaking here of the practical difference, not some difference that was originally hypothesized in the dissertation.]
Thrift contains both an RPC and an IDL, but they don't necessarily have to be used together. Protobufs is just an IDL; gRPC is the RPC, which was released just a year or two ago.
You would layer Thrift and REST by putting a REST API over the top of an interface defined in the Thrift IDL. You could also run the Thrift RPC for Thrift-compatible clients.
Say you have a user profile, which has a Gravatar associated. Sure you can have a getUserProfile() procedure that fetches the user information, but what about the image? You can write a getUserAvatar() procedure that proxies it, but that's wasteful.
In a RESTful system, you have a Resource Identifier (URL) that you can indicate as an hypermedia reference (link), with which the client can use a standard data fetching verb (GET) to retrieve it directly from the other server.
Of course, in a practical setting the getUserProfile() procedure would return the URL, but that's just an admission of the limitations of RPC vis-a-vis REST.
On the other hand, REST itself has its own problems and limitations, and is certainly not adequate for every use case, as Fielding's dissertation mentions at length.
REST doesn't have a uniform interface in practice, either.
I haven't read the dissertation so I can't really comment on the hypothetical REST (though it is on my reading list now, and not that it really stops anyone else), I can only comment on what, in the real world, passes for a "REST API".
"REST" principles certainly sound nice on paper, but for the most part, it's clear that they're completely implausible to realize in a wide-scale, meaningful way. After over a decade of pro-REST propaganda, people still can't even tell if their interface is "RESTful" or not.
The parts of "REST" that have worked are the two simple basics of HTTP: GETting a resource to read it, or POSTing a resource to write it. Nothing else has really stuck or can be expected to have a uniform meaning (and even POST's behavior will vary, with some doing an upsert-style operation and some accepting it only for new writes and using PUT and/or PATCH for edits). 200 OK means it worked most of the time, but sometimes people will return a plaintext error with it. 404 might mean that the resource is not found, or it might mean that the route is not found/no longer valid (or that it was called with invalid or improperly encoded parameters). There are a bunch of esoteric codes that are used to mean a lot of different things, always depending on who the implementer is.
So the "uniform interface" is just that everyone is using HTTP, to mean all sorts of different things. In practical terms, it doesn't really amount to much, except a lot of blathering over whether something conforms with a theoretical ideal that everyone has already demonstrated they're unwilling to conform to.
REST has been extremely successful, having scaled to billions of services, like the one we're using right now.
"RESTful APIs" have mostly been a failure, I fully agree with you on that. The difference is that I think it's a cultural problem; when people like Licklider sensibly thought about a future wherein computers would learn to talk to each other (of which REST is a first step), as static protocols obviously didn't scale, we proved him wrong by sheer brute force. Watching something like Bret Victor's The Future of Programming, it's hard to miss the giant indictment of our whole profession.
That said, since I know the term is hopelessly lost, I don't push for REST either. Our service uses XML/JSON-RPC.
Of course you can. But x86 machine code doesn't have Monads just because Haskelll can be compiled to it. In both cases, the concepts have to be broken up to be implemented, as they are not meaningful at that level.
Can you please explain. Which REST concept cannot be implemented? I think the problems that REST/SOAP solve,is that the "levels" that you speak about, have already been implemented by someone else. I am talking of serialization, transport level details (e.g. SOAP over JMS) etc. If even transport level abstraction has been taken care of by the implementers, then which concept do you think, cannot be implemented.
I would love to use it for Go programming but I'm so used to vim key bindings that it's hard to switch. I can use IntelliJ because their vim plugin is pretty good; anything of similar quality for VS Code?
Unfortunately it's not on par with actual vim or what you get with Sublime and IntelliJ.
The vscode vim plugin mostly emulates the modality of vim, without support for things like :%s/x/y/ substitutions and other commands.
I'm hoping that with time it will mature and improve. Haven't seen any improvements over the last few months though (I last tried it about 2 or 3 weeks ago).
I've tried three, and VimStyle has been the best by far. The plugin marketplace shows it having a lower number of installs, but that's probably due to it being a bit later to market than the others.
Yup the only reason I'm currently using Atom over VS Code is because of the VIM bindings, even though pretty much everything else about VSC is better (including feeling more snappy)
I also completed this specialization, but unpaid so did not do the capstone project. I agree with most of your take/skip assessments. The Statistical Inference course was particularly disappointing. I recommend the excellent Data Analysis and Statistical Inference (https://www.coursera.org/course/statistics) to fill in that missing area of learning.
I was just about to sign up for the Statistical Inference class, and happened to read some reviews before hand. I'm glad I did. A number of people have pointed out how that class diverges from the others, becomes very math heavy without covering basic pre-requisites, etc. Everybody is saying to make sure you've taken a least a basic Statistics class before taking that one, and since I haven't had a Stats 101 class, I'm going through a bunch of Stats material before signing up for this class.
I'm still going to take it since I want to finish the specialization, but I'm glad I didn't wind up diving into it blind. I think I would have struggled with it if I had.
Recently moving from Python to Java. `pip` doesn't even come close to Maven. Dependency management used to be something I needed to manage much more closely in Python. With Maven, it just works.
I'm just curious as to why. You specify a list of requirements and their versions, and those get pulled down from somewhere and installed locally. What makes Mavens process far superior to pip (or npm, or any other program)?
Because with JVM languages, and their "horrid" backwards compatibility (that everyone always loves to bash), I can declare dependencies on libraries written in Java 1.1, and it will JUST WORK.
From what I understand, there's a fairly large chasm between Python 2/3 (such that a lot of people use external libraries to deal with coding cross-compatibile code, and apparently get wrong some-times).
It's not completely free, and not completely open source, but we've been very happy with Octopus Deploy https://octopus.com/
That and Topshelf https://github.com/Topshelf/Topshelf have made deploying Windows services very easy. Topshelf is slowly adding some Linux/mono support, and OctopusDeploy supports SSH as a deployment option, but unsurprisingly things aren't as nice if Windows isn't your target.
Microsoft now employs 118,584 people with many of them working in research laboratories. Had Gates pursued academia he could have at best accomplished a fraction of what he has.
The template from https://themeasureofaplan.com/budget-tracking-tool/ has everything I need and a perfect level of flexibility to customize it for your needs.