john mitchell @daeyoung@qoto.org

Nice!

https://towardsdatascience.com/meet-julia-the-future-of-data-science-52414b29ebb

#julialang

Never thought Elon Musk would do so much for the adoption of a decentralised infrastructure…

Please Elon, can you buy Elsevier ?

In retrospect, these two tweets may have been Elon's most visionary.

@d8aray yes, I can see how it might help some people that are afraid of writing code. That said, I think #julialang does a great job if you want to take the leap to programming.

For example, https://github.com/mossr/BeautifulAlgorithms.jl really impressed me, some algorithms are so elegant and simple!

The official app is limited. Once you’ve gotten comfy on here I suggest you ditch it.

Toot! is a paid app and worth it. Filled with delightful touches and a glorious UX.

Metatext is a free open source app that has a lot of features but no frills.

Tooot, yeah three o’s, is a minimalist app better than the official app.

Mammoth is currently in TestFlight beta from the dev that looks super-promising but lacks key features at this point but it’s 1 to watch.

Having been here since 2016, I can tell you there is definitely no such thing as a consensus on usage of content warnings on the fediverse. It's a decentralized network that doesn't belong to any one party, so by definition there is no single culture on it. Different corners have different expectations and customs.

boost to pet the cat
＿＿
　　　　　／＞　　フ
　　　　　| 　.　 . l
　 　　　／` ミ＿xノ
　　 　 /　　　 　 |
　　　 /　 ヽ　　 ﾉ
　 　 │　　|　|　|
　／￣|　　 |　|　|
　| (￣ヽ＿ヽ)__)
　＼二つ

@daeyoung @andrew My first programming language was java...I have a special hatred in my heart for OOP, and I'm glad things like scala/clojure etc. exist on the JVM to make it actually useful 😂

My number one recommendation before diving in is installing [DrWatson](https://juliadynamics.github.io/DrWatson.jl/dev/) to make package management easier and to prevent dependencies from clogging up your main environment, but reach out if you'd like more! I'm always happy to make conver- I mean, umm...show people alternatives...MUHAHAHAHAHAHA 😂

@daeyoung @andrew "Right" in terms of interacting with both computers and data, (and package management) it beats R and python IMO.

TL;DR up front: I've found I can accomplish much more with much less, and in a much less convoluted way with julia, and I've used R for 8 years, and julia for 3-4, and python intermittently in that time as well. Read on for why I like it.

Some simple syntax examples:

No tabs/spaces issues like python, every block starts with a signifier like function, if, else, etc. and ends with "end". This makes it very easy to track "delimiter" position and catch unclosed forms.

**Broadcasting functions** (write a function to operate on a scalar, then apply the following)
f(x)=2x
f(2)->4
f(1:2)-> Error, doesn't accept vectors
f.(1:2)->[2,4]

**Broadcasting the broadcast:** if you want to apply other broadcast operators with more complex functions, there's a macro for it:

y=[1,2]
(f(y)+12/)37 -> fails
(f.(y).+12)./37-> works
@.((f(y)+12)/37)-> works

So you can write expressions to operate on single values, test them accordingly, and have guarantees they'll apply correctly in an n-tensor context.

Oh, and speaking of n-tensor, you can easily replicate the outer product function in R with broadcasting, and you can still use any binary function as you can in R:

julia:
x=[1,2,3,4]
x.*x' returns a product matrix
vcat.(x,x') returns a matrix of paired x values.

R:
x=c(1,2,3,4)
outer(x,x)
the second example doesn't work in R with outer(x,x,c), and that data structure seems to need manual creation with the matrix function (and it behaves weird anyway).

**Mixed iterator loops:**
Instead of:

for i in 1:10
j in i+1:11
do something on i and j
end
end

We do:
for i in 1:10, j in i+1:11
do something on i and j
end

And you can add arbitrary amounts of iterators into the flattened statement to make it clear where the logic is happening, and which iterators belong where in nested loops.

**First class functions:** ease of closure construction, and lambdas are cleaner:

just lambdas:
R: {function(x){return x^2}}
python: (lambda x: x + 2)
julia: (x->x+2)

And lambdas can be nested for nested higher order functions. Like so:

map(x->filter(y->y[,1]!=2,x),data_frame_list) (or something like this)

**Making code parallelized** is trivial in most cases. Write a function, wrap it with the @everywhere macro and put it in pmap. The same function can be effortlessly compiled to cuda with the @CUDA macro, since almost all of julia and its packages is written in pure julia. (Side effect: no need to be a C++ expert for performance, and modifying dependencies for your work is easy.)

**Bonuses:**

Package management, creation, and code-sharing between machines is trivial with helpers like DrWatson, which is excellent for academic users, and per-package manifests. (And no pip/conda nightmares)

Dataframe support is excellent, and has similar functions to melt/cast built in. Adding to this, indexing rules make sense as compared to R's [[]], [], and the differences between $name and [,col] when working with tibbles.

Gadfly more or less == ggplot2 but with more features, and different back-ends like plotly are also available for plots.

Finally, multiple dispatch is pretty dang neat, and the type system doesn't "try to help" like it does in R which leads to all sorts of wacky bugs that are difficult to locate (like when R tries to help with lists/vecs/matrices,etc).

e.g.
function(x)=x^2 gets compiled to
function(x::Int)
function(x::Float)
function(x::Real)
etc.

But you can specify you only want one and you'll only get that one, and it also speeds up compilation to a degree.

If you decide you want all of them, the appropriate one is dispatched when required, and this doesn't have the same limitations of traditional overloading. As explained better [here](https://discourse.julialang.org/t/is-multiple-dispatch-the-same-as-function-overloading/4145/5).

**End**

I hope that helps explain my position, but much of this may just be preferences on my end in terms of how I think about solving problems, and how well this language comports with that. I do suggest giving it a try though, you may like what you find after getting over the initial friction of switching languages. 😄

Guide to Content Warnings

On qoto, the only toots that require a content warning (CW) are:

- Spoilers
- NSFW (Not Safe For Work) – this is up for interpretation, but I assume refers to tits and dicks
- Using a derogatory epithet or racially charged language in a toot that itself is not racist, sexist, homophobic or otherwise hateful speech (such as quoting a passage from The Adventures of Huckleberry Finn for critical purposes)*

Other reasons someone may want to use CW’s here on qoto:

- Strobe effects (to avoid triggering an epileptic seizure in people who are susceptible)
- Violence, accidents, rape, suicide, self-harm, death, etc., including to non-human animals (PTSD, etc.)
- Food (pics of food can prompt people with metabolic syndrome, eating disorders, which are relatively common)
- Pics of drugs (may trigger use by people who are addicted)
- Very long posts (so uninterested readers don’t have to scroll through them)

It’s better if the CW description is more specific (without itself containing CW-eligible content). Instead of just “Spoiler”, say “Spoiler – The Wizard of Oz”. Also, it’s generally a good idea to repeat the CW description within the toot itself at the top of the toot for those who may have the auto-open feature enabled.

What doesn’t need a CW:

- swear words
- content that might hurt someone’s feelings
- unpopular opinions
- political content
- pictures of animals (that are alive and well)
- content from those with autism or who are otherwise neuro-atypical
- using the CW as a title or heading for your toot or trying to place actually content into the CW description is irritating for others

Overuse of the CW feature ultimately undermines it’s usefulness because it forces people to have to click on each toot or just enable the auto-open feature. However, someone with a condition like epilepsy or PTSD, the auto-open feature is not really an option so CW overuse effectively forces people with disabilities to click each toot while everyone else can just enable the auto-open feature, which doesn’t seem fair.

Other Mastodon instances have varying rules and views on CW use.

Note: I’m not an admin or moderator here, this is just my opinion. I don’t always adhere to these guidelines and you can do what you want.

- - - -

* This epithet restriction isn’t listed in the rules, but it was adopted as a compromise in response to some specific events. Of course hate-based speech such as sexist, racist, homophobic or anti-trans speech will not be tolerated. (Note: I personally block anyone who uses epithets in any context because the intent is often ambiguous and you can communicate the same info without explicitly using the epithet.)