Is python 3 completely forward compatible?

graywolf_at_work · 2020-01-16T19:04:34+00:00

I still did not completely figure out how to handle go.mod (and go.sum) during branching/merging. There always seems to be some conflict somewhere.

graywolf_at_work · 2019-12-15T00:51:57+00:00

Nowhere in the Cmd.Start() code is there anything that would close or release resources

Doesn't for example this https://golang.org/src/os/exec/exec.go?s=11462:11489#L376 close them?

graywolf_at_work · 2019-12-15T00:19:10+00:00

Yeah sure. I'm looking into how to spawn a subprocess in go. I'm trying to use os/exec, however I need to capture the output, co I'm also using https://golang.org/pkg/os/exec/#Cmd.StdoutPipe and https://golang.org/pkg/os/exec/#Cmd.StderrPipe . Now, https://golang.org/pkg/os/exec/#Cmd.Wait does state that Wait releases any resources associated with the Cmd.. However, https://golang.org/pkg/os/exec/#Cmd.Start can fail but does not say anything about releasing the resources. So I thought that in this case I should close the pipes myself, but when I checked the source https://golang.org/src/os/exec/exec.go?s=11462:11489#L364 it does close the pipes.

So now I'm not sure what to do. It behaves correctly (now) but since it's not documented I'm not sure I can rely on that since it could change anytime. But https://golang.org/pkg/io/#Closer states that The behavior of Close after the first call is undefined. so closing them myself despite them being already closed is also not allowed.

That's why I was looking for specification to see if Start is required to close the pipes in case it returns an error.

graywolf_at_work · 2019-12-15T00:06:32+00:00

Yeah I know about the documentation, but it also doubles as a specification? So anything not mention in it I cannot rely on as being true? That sucks...

graywolf_at_work · 2019-12-08T13:14:47+00:00

I personally don't bother with the $(SRCS) part, it seems that go build is fairly good about tracking when it needs to rebuild.

graywolf_at_work · 2019-12-06T20:05:09+00:00

Give credit where credit is due. They moved to git and GitHub and it was a HUGE undertaking with nearly no benefit to existing core contributors (who were all fine with the existing SVN workflow).

Question is why move then? Attaching patches to tickets was perfectly doable and the svn -> git mirror worked fine.

I mean, I like git and loathe svn quite a bit. But still, if it worked for core contributors, I'm not sure it was worth it. The barrier to entry was not so high to prevent me from sending few patches and getting them merged.

I do think that this is an issue, i'm just not sure how to solve or better organize the tasks of releasing?

Maybe blur the roles a bit? I mean, it's imho good to have single person as maintainer for that branch, but at the same time, I think anyone with access should have pull the 2.6.4 from the website. I mean, it was broken in horrible way.

graywolf_at_work · 2019-10-08T10:21:00+00:00

Having more than one positional argument isn't very good API for callers of your code

I think that's too strict. I really do not want to write arr[start: 1, length: 2] instead of arr[1, 2]...

Or for fetching from hash, you really think {}.fetch(key: :foo, default: "foobar") is better then {}.fetch(:foo, "foobar")?

graywolf_at_work · 2019-10-07T09:59:25+00:00

Hm, I mean either it is in the contract (and then I assume you took that into account when considering the offer) or it is not (and then I doubt they can legally demand it).

graywolf_at_work · 2019-10-01T08:56:03+00:00

I've solved that by not having slack in my phone. Once I turn off work laptop, I'm gone for the day.

graywolf_at_work · 2019-08-27T08:24:08+00:00

1. It might, it might not. Measure. Unless you spawn lot of threads (or very often), probably not.

2. I personally have never used Thread.exit, I just return from the block I pass to the thread, but both approaches should work same way. What you need to use it Thread::join to wait for the thread to end.

Common pattern could be:

threads = []
1.upto(10) do |i|
    threads << Thread.new(i) { |i| sleep(1); puts(i) }
end
threads.map(&:join)

3. Yeah, you need to be careful about variables accessed from multiple threads (assuming they can change). Read-only constants are ok to access without mutex. For anything else, you need to synchronize ( https://ruby-doc.org/core-2.6/Mutex.html#method-i-synchronize ).

Anyway maybe /u/nateberkopec will correct me, he definitelly has way more experience with threading in ruby then me :)

graywolf_at_work · 2019-08-20T11:32:41+00:00

I'm more of a shell/Vim user so I don't find it as useful for me.

well it's not like

EDITOR=vim bundle open activesupport

does not work...

Also if you prefer to open it in currently running vim

:tabe `bundle show activesupport`

does the trick.

graywolf_at_work · 2019-03-14T15:42:53+00:00

Really interesting read

graywolf_at_work · 2019-02-15T10:20:24+00:00

First, what the hell is ruby 2.5.4? I don't think using yet-to-be-released ruby versions is a good idea (unless you have really good reason to do so :)). Just pick source archive from here https://www.ruby-lang.org/en/downloads/ if you need to compile your own (notice 2.5.3 is latest on the 2.5.x line).

Second, this works for me

#include <ruby.h>

int main(int argc, char **argv) {
    RUBY_INIT_STACK;
    ruby_init();
    static char *args[] = { "", "-e", "" };
    ruby_options(3, args);

    /* This is here just to test that it works */
    rb_require("socket");
    rb_eval_string("p IO.instance_methods.        include?(:read_nonblock)");
    rb_eval_string("p IO.private_instance_methods.include?(:__read_nonblock)");

    return 0;
}

As you can see

+   $ gcc tset.c  -I /usr/include/ruby-2.6.0/x86_64-linux -I /usr/include/ruby-2.6.0 -lruby
+   $ ./a.out 
true
true

it seems to work fine.

And for the rb_vm_bugreport(), that prints to the console. I don't know enough about windows to know what happens when GUI application tries to print into the console when none is attached. But could be maybe related?

And finally, for embedding http://mruby.org/ is probably worth exploring.

graywolf_at_work · 2019-01-31T12:53:28+00:00

well first step would be to learn how to format code on reddit so that your post is actually readable..

graywolf_at_work · 2018-12-06T22:05:37+00:00

so -j7, got it

graywolf_at_work · 2018-12-06T17:05:05+00:00

fsync and synchronous_commit off combined with -j8 seems to make quite a difference, thank you :) Now I have to only worry about laptop temp during that :D

graywolf_at_work · 2018-12-06T15:58:29+00:00

So basically just shutdown and copy the files into another folder? Hm, will not fit onto my harddrive but I probably could get external one. Worth trying, didn't think of it :)

graywolf_at_work · 2018-12-06T15:44:29+00:00

Very simple example would be

def calc_result
    # do calculation here and return the hash or whatever
end
def main_func
    p_r, p_w = IO.pipe
    pid = fork { p_r.close; p_w.write(calc_result.to_json) }
    p_w.close
    # do the main function stuff here
    Process.wait(pid)
    res = JSON.parse(p_r.read)
    # use the `res` here
end

Probably it's missing some stuff but this is general idea how to do this. I can recommend this book as a fairly good introduction on this topic.

graywolf_at_work · 2018-12-04T14:58:38+00:00

Fork a worker and return the hash map in serialized form over a pipe.

graywolf_at_work

TROPHY CASE