I think AWS has competing solutions, but I am not sure about the current state of affairs.
479 karma · joined January 16, 2017
I think AWS has competing solutions, but I am not sure about the current state of affairs.
Small nitpick: I think "In the meantime ... have a game of skifree :)" would be prettier (note the 3 dots).
Integer a = new Integer(2);
Integer b = a;
Here a == b and no comparison by value. Integer c = new Integer(2);
Then a != c but a.equals(c) (in Java). My point is that I do not agree with that and would like to have a == c, which would be the case if '==' was implemented using comparison by value.It is just a bad idea to implement the '==' operator using comparison on addresses instead of on values and I consider languages pretty low-level that do that.
In a sane language == is always a function adhering the attributes of an equivalence relation (reflexivity, symmetry and transivity), where a user can expect an actual value comparison - AFAIK one is advised to overwrite `equals` in e.g. Java, but I do not think this is good design.
//edit:
There is no obvious answer, as one could argue, that languages just use different names for the same concepts ('==' vs 'equals') and consider comparison by value or by reference more fundamental (and choose '==' for that).
I used the original Caffe and thought it was built by Berkely University - Caffe2 only shared the name I guess?
What is the advantage of having "int", "long" types that just give minimum byte requirements (with associated storage classes, etc.) instead of more specified types like int32_t and uint8_t? In the end you deal with fixed-size integers or not (using some bignum library), but if you deal with them you have to take their byte length into acount in your code anyway I would say (to deal with overflows and stuff).
May I ask what you consider large memory - MByte, GByte, TByte? The simplest solution is to store it as a blob on a SSD, and read it via simple file IO or put it into a DB. But I assume this was too slow, so it would be interesting to go into more details.
In the end you can do shared memory with multiprocessing in Python, which - I have to admit - requires some setup and bookkeeping work.
Sure, it's a problem for specific workloads, and Python will get there eventually - I just don't think it is a deal breaker.
Just joking, it's a nice framework. However don't forget other projects like caffe which also contributed to ML and DL research.
Now that is some good SAT solver name - keeping user's expectations low, I guess? Nice choice! ;)
However the author missed that there is a special case for N == 1, where actually P == NP (sorry, I could not resist).
Often the challenge is a big amount of (hopefully read-only) data that you want to access in every 'your_func'. The naive solution is to copy the data, but this might blow your memory.
> Parallelizing your number crunching is probably not going to work very well. [...]
The question is, what exactly does "number crunching" mean? We do aerial imagery analysis, so image processing in essence, which I would classify as a "number crunching" problem. A common thing e.g. is to do a time-series analysis and you can simply start multiple (2, 4, ..., N with clusters, etc.) processes for each problem. Obviously this works because most methods are computation and/or memory heavy - the additional memory requirements and "overhead" of Python itself (IMHO people overestimate the weight of starting new processes instead of threads) is completely dwarfed by the requirements (memory and CPU) of the method itself.
E.g. in the remote sensing and earth observation domain you can simply divide your problem (e.g. semantic segmentation) into (maybe over-lapping) subproblems (via e.g. tiling) and start separate processes for each image processing tool-chain.
Granted you may not utilize your resources to the full extent by only applying multiprocessing (and ignoring threading), but in my experience you can solve a lot of problems by simply applying map-reduce-like programs and optimizing for throughput.
There was recently a thread about crafting plausible maps (aka "mapmaking", a related topic).
It's similar to a webpage that posts C code to a web service and returns the output of its stdout (so like CGI). Not that this is a bad thing, but when I read about stuff running in the browser, I suppose the code to be run by the browser itself, and not just visualizing the output of a program run on some remote server.
Some people "sandbox" it in Docker (and this is controversial AFAIK), but although I like the notebook UI, I don't want to give people a "native" shell just to do some data exploration.
$ apt install joe
And it's ready (obviously you might want to configure it differently than the default).Some time ago I did more Java and used Eclipse heavily and its debugger was really nice, so I share your opinion that you get nice features.
However if you are working on a project (at least that has been my experience so far) that does a lot of multiprocessing (let's say a web service with a processing scheduler in the background calling into processes implemented by different languages) and you may have bugs on several layers using different programming languages, I like the fact that I can use the same concept for all of them and write some custom "debug.log" that I can later analyze (obviously good logging in the first place can help a lot).
But I may check them again: Do modern debuggers work across languages (assuming available source), let's say web-request -> Python -> FFI -> C++?
Previously such scenarios have been non-trivial to debug (although there are some pretty advanced multithreaded code analyzers now), but maybe it has changed for the better.
Am I missing out? AFAIK step-back debuggers are still more research (I think Elm has something like this), but otherwise I just want to have system snapshots and there print($foobar) works very well for me across languages.
I think that is too harsh. Although Krita can do more than Paint the user-experience is pretty well done and it also works for basic tasks providing useful defaults.
However curses and terminfo are big programs and most terminals they support are not in use anymore, so if one is OK with supporting just 99.9 (and not 99.999 like curses)% of modern terminals (say xterm, linux-console, st, urxvt, $otherterm), it is feasible to roll your own or use an alternative like e.g. termbox (https://github.com/nsf/termbox).
It provides a simple API like "write Unicode-Char to position x/y in specific $style" and some utility functions to setup the terminal (e.g. one has to consider how to react to window-size (== terminal rows/cols size) events). You can then write your app similar to a game-loop like the following:
while state['should_run']:
render(state)
update(state)
get_input(state)
I think such an API is pretty nice to work with - this is different to the React approach, but for writing terminal GUIs like text editors it worked pretty well for me.Many (native) games use a similar approach when rendering menu's and stuff and although there are terrible ones most menus of games look pretty slick.
Haha, thanks.
If there's a Go2 there will be a lot of these headlines for blog posts/rants.
It doesn't matter if it is true or not, but that phrase is wonderful.
> Sometimes I just want to create a map and mutate its structure, and the language saying "no" is constraining me in an unpleasant way.
Languages that provide immutable data structures have often 2 variants, an immutable and mutable. Why can't you just take the mutable in that case?
I think it's more about making immutability or mutability explicit.
Actually I am not a native English speaker, I translated it literally from German where we also say "Kurze Frage [...]".