HNHacker News
TopNewBestAskShowJobs

zeptomu

479 karma · joined January 16, 2017

echo -e moc.liamg\\x40umotpez ohce|rev|sh
submissionscomments
zeptomu··on Azure Functions Now Support Java
Are there any other "Kubernetes-As-A-Service" providers other than GCP?

I think AWS has competing solutions, but I am not sure about the current state of affairs.

zeptomu··on The Most Officialest SkiFree Home Page (2010)
Very nice.

Small nitpick: I think "In the meantime ... have a game of skifree :)" would be prettier (note the 3 dots).

zeptomu··on Weird Python Integers
Can you elaborate on this?

  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.
zeptomu··on Weird Python Integers
Yeah, well you know, that's just like your opinion, man.
zeptomu··on Making your first dollar from a SaaS project
But it can also have the opposite effect: people get put off as they think the product is vaporware (rightfully).
zeptomu··on Weird Python Integers
I agree, that's why I revised my answer (see edit). Probably comparison by-value is more useful in higher-level and comparison by reference in lower-level languages.
zeptomu··on Weird Python Integers
Although you are technically correct (the best kind of correct), it is still a shortcoming of objects (or maybe just their implementation in Java).

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).

zeptomu··on Explaining React's license
What - Caffe2 is a Facebook project?

I used the original Caffe and thought it was built by Berkely University - Caffe2 only shared the name I guess?

zeptomu··on 64-bit Firefox is the new default on 64-bit Windows
If you think about it, I think its a little bit a fault of the language (AFAIK the C specification) defining basic integer types too loose.

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).

zeptomu··on Let's Remove the Global Interpreter Lock
> create a very large in memory read-only pd dataframe and then put a flask interface to operations on that dataframe using gunicorn and expose as an API. [...]

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.

zeptomu··on Let's Remove the Global Interpreter Lock
Agreed, but there is a lot of misinformation about the topic. I met developers that thought the GIL prevents you from running your program in multiple instances at the same time on one machine - which is obviously not the case.

Sure, it's a problem for specific workloads, and Python will get there eventually - I just don't think it is a deal breaker.

zeptomu··on Google Hires Chris Lattner for Its AI Team
I am not sure if this comment has been built by a bot given positive sentiment to TF. Maybe the first step to skynet is applying aggressive marketing for the framework itself to bootstrap itself?

Just joking, it's a nice framework. However don't forget other projects like caffe which also contributed to ML and DL research.

zeptomu··on A Solution of the P versus NP Problem?
> In particular, I helped design MARMOSET (Marmoset Automated Reasoner Mostly Only Solves Easy Theorems), a competitive SAT problem solver. [...]

Now that is some good SAT solver name - keeping user's expectations low, I guess? Nice choice! ;)

zeptomu··on A Solution of the P versus NP Problem?
If this is true (and the proof has no flaw), it would be huge and pleasant (many expect it, although there are some who think it's a problem that might be unprovable in our current logic framework). So let's see how it works out.

However the author missed that there is a special case for N == 1, where actually P == NP (sorry, I could not resist).

zeptomu··on Let's Remove the Global Interpreter Lock
This is a nice pattern and there are surprisingly many problems that can be solved that way. AFAIK you do not have to join() here as the processes die after the map call.

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.

zeptomu··on Let's Remove the Global Interpreter Lock
See my other replay in this thread.

> 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.

zeptomu··on Let's Remove the Global Interpreter Lock
I am a heavy user of Python and its scientific libraries (numpy, etc.), and although I know about the GIL, I have to add, that for us (we do a lot of scientific code-prototyping to evaluate remote sensing processing methods) the GIL hasn't been a problem so far.

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.

zeptomu··on Worldbuilding
https://news.ycombinator.com/item?id=14989538

There was recently a thread about crafting plausible maps (aka "mapmaking", a related topic).

zeptomu··on Jupyter C Kernel
Not to nitpick, but "[...] running C code in your browser" is a little bit of an exaggeration as there is no state-sharing between cells.

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.

zeptomu··on Jupyter C Kernel
What is the state of the art concerning security of Jupyter? As it provides in essence a remote shell it's vulnerable to local privilege escalation.

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.

zeptomu··on Text Editor Performance Comparison (2016)
Assuming you are on a proper OS, it comes with your distribution, e.g. via Ubuntu it's just

  $ apt install joe
And it's ready (obviously you might want to configure it differently than the default).
zeptomu··on Porting 4.5K lines of C to Go
:)

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.

zeptomu··on Porting 4.5K lines of C to Go
I have to admit, although I use domain specific debuggers sometimes (gdb, debuggers of IDEs), I mostly debug via print-statements, as it just works in most scenarios.

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.

zeptomu··on Exa, a modern replacement for ls
Asking the important questions. Maybe exa could show a flying axe?
zeptomu··on Microsoft Paint to be killed off after 32 years
> Krita is an alternative to MS Paint in the same way that operating a railway network is an alternative to driving a bicycle

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.

zeptomu··on Microsoft Paint to be killed off after 32 years
You may also try Krita - I think it's pretty well done.
zeptomu··on Ink: React for interactive command-line apps
Some time ago I built a (terminal) text editor and one of the challenges is to implement the renderer which is normally done by messing with termios and changing some terminal parameters - as this is "device"-dependent there exist databases like terminfo and abstraction-layers like curses which give you an API similar to "Write this text at position x/y in green".

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.

zeptomu··on Toward Go 2
Underrated comment. :)

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.

zeptomu··on Fantastic DSLs and where to find them
If your data is immutable or not is significant for program analysis and correctness, so I would say the distinction makes absolutely sense.

> 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.

zeptomu··on Spoilerwall: Respond to port scanning requests with movie spoilers
I concur - that was the reason at least for me.

Actually I am not a native English speaker, I translated it literally from German where we also say "Kurze Frage [...]".

← PreviousPage 3 of 6Next →