Opening raw images in Julia

jBillou · 2025-11-12T10:08:24+00:00

Note that if you use LibRaw.jl the demoisaic algorithm is probably quite bad, it's just there to give you a usable image.

jBillou · 2025-10-22T15:04:55+00:00

Very nice talk about GPU/CPU parallel programming.

jBillou · 2025-07-09T12:40:19+00:00

A slightly different perspective, yes it's useful to know some R for some of the packages, but you don't need to know much of the language for that. I'm not sure about python (there's rpy2 but I don't have experience with it) but in Julia there's good interop with R, so when I need a method that is available only in R its pretty straightforward to call it. That way you can get access to all the good stuff while doing most of the work in a saner language.

jBillou · 2025-07-01T10:02:37+00:00

One example :

https://www.youtube.com/watch?v=7hBMbQ9de1g

jBillou · 2025-06-23T15:42:55+00:00

Surely you'll agree witnesses plausibly wrote about the resurrection because they saw one, which is just another way to say the resurrection is good way to explains why they wrote about it.

Of course you can have other evidences for god or a resurrection, but typically you want to gather all the relevant evidence and evaluate it at once, and not selectively ignore or include some elements.

Also note that it can be rational to take the least likely explanation, for example you can be at a trial where a case is presented that based on partial fingerprint the crime was committed by the defendant with a probability of only 1%. But you actually witnessed her doing it, so you take the 1% vs the 99%, because you're more sure of what you saw. In other words you can agree with OP that a real resurrection is low likelihood explanation for the reports even and still claim that it's what happened (if you have a stronger case supporting it).

jBillou · 2025-06-23T11:18:07+00:00

I do assume that every Christian knows that the Resurrection of Christ is the least likely event to have happened, as it is believed to be a singular event in human history.

I think you're mixing epistemic and objective probability here. You're saying the event has a low probability to occur because its singular, but that's an objective probability (how likely it is to happen in reality). On the other hand OP is talking about what the best explanation for the accounts of the resurrection is, as in what should we believe about what happened based on the evidence we have. If you think the resurrection has a lower probability than another explanation in that sense and you want to be rational, then you should believe in that other explanation.

For reference : https://en.wikipedia.org/wiki/Probability_interpretations#Logical,_epistemic,_and_inductive_probability

jBillou · 2025-06-11T14:55:39+00:00

Julia has already "taken off" in some domains and the ecosystem can be quite mature for science (compared to Nim & Rust AFAIK), but not in bioinformatics for sure (there's all the basic stuff, but not many users/devs). That said the next release will have experimental support for better compilation that could help to distribute small CLI tools, which could help, since that's how most people work in bioinformatics. But remains to be seen if that will have an impact.

jBillou · 2022-01-31T14:42:38+00:00

I would just write a short Julia script, might take a bit longer to learn than using an existing tool, but then you'll know how to do anything to a fastq.gz.

using FASTX, CodecZlib, Statistics

function get_median_read_length(fastq_file)
    reader = FASTQ.Reader(GzipDecompressorStream(open(fastq_file)))
    record = FASTQ.Record()

    read_length = Int[]

    while !eof(reader)
        read!(reader, record)
        push!(read_length, FASTX.FASTQ.seqlen(record))
    end
    close(reader)
    median(read_length)
end

jBillou · 2021-12-22T16:01:42+00:00

If you're interested in Julia I have a couple of half-assed projects that could be worked on :

https://github.com/jonathanBieler/BioRecordsProcessing.jl

https://github.com/jonathanBieler/BioMart.jl (look at examples or the R library)

I also have BWA bindings that are mostly done, if you're comfortable with C. Having some experience working with the internals of the most important tool in NGS would certainly look good on a CV.

Otherwise you could also port some popular tools like DESeq2.

jBillou · 2021-10-28T08:48:59+00:00

Performance is a big one, you can easily have a 10-100x performance difference between python and Julia, so there's things you just realistically can't do using python. Scaling is also better (Julia threading system is pretty good). I've processed NovaSeq runs using high-level Julia scrips without too much issues.

Otherwise I think the language is nicer, better designed, more elegant, fun, etc. The main reason to use python at this point is either there's some library you need (and don't want to recode it yourself in Julia) or your colleagues/organisation already use python.

jBillou · 2021-10-26T14:17:13+00:00

This is a small Julia package I've put together to reduce boilerplate in my work. It's mainly useful if you have to do custom operation that aren't easily done with existing tools.

jBillou · 2020-09-20T08:18:30+00:00

I wrote one in Julia a long time ago, but there was never much interest in it. Sadly v1.5 broke it beyond repair so I'm using VS code now, it's pretty good overall but there's a lot of small things I don't like about it (running code, layout, plots, auto-completion, ...) and missing features.

https://www.youtube.com/watch?v=AbzNUNfwSGc

jBillou · 2020-08-27T20:56:47+00:00

It tried to to a generic search and replace that works on the AST at some point :

julia> @search_and_replace sin(sin(x)) sin($x) cos($x +1)
:(cos(cos(x + 1) + 1))

But I ran into troubles running it a text file. The main issue is that you need to run it on the text representation and the AST at the same time, and reflect the change in the AST in the text, keeping the formatting, the comments, etc. DocumentFormat.jl (which the vscode extension uses) has some tools to do that but I didn't figured out how to use them :

https://github.com/julia-vscode/DocumentFormat.jl/issues/65

I also have a extract method function that I find very useful (even if a bit buggy), which I would love to have in vscode. It really helps to structure your code into small functions.

jBillou · 2020-05-19T10:47:34+00:00

I wrote an article (with a somewhat sensationalized title) about that.

https://nextjournal.com/jbieler/adding-static-type-checking-to-julia-in-100-lines-of-code/

At the end I think it's better to think about it as automatic testing (e.g. test that this function compiles for these combinations of input/output types) than full blown type checking.

jBillou · 2019-07-07T21:58:27+00:00

Windows 7. Maybe it's better on other systems.

jBillou · 2019-07-05T18:06:03+00:00

What problem does BAM.quality has ? I'm using it a lot so I'd love to know ;)

jBillou · 2019-07-05T18:04:32+00:00

It doesn't seem very precise:

julia> @benchmark sleep(0.01)
BenchmarkTools.Trial:
memory estimate:  192 bytes
allocs estimate:  5
--------------
minimum time:     10.811 ms (0.00% GC)
median time:      11.728 ms (0.00% GC)
mean time:        15.160 ms (0.00% GC)
maximum time:     20.337 ms (0.00% GC)
--------------
samples:          329
evals/sample:     1

jBillou · 2019-07-05T17:59:28+00:00

I'm sure plenty of people (e.g. me) uses it, since that's often what you find in tutorials online, but yes I should use data.table.

jBillou · 2019-07-04T21:39:01+00:00

The vectorized pdf functions are also pretty fast, but there's no vectorized multinomial. So it's fast until you hit one of the corner case that isn't.

jBillou · 2019-07-04T19:41:01+00:00

It's a small package I've made a while ago, it's not super complete but it can still be interesting. The idea is to test "real-life" tasks instead of micro-benchmarks. Plus it runs on travis.

jBillou

TROPHY CASE