I’ve been learning python for a year for data science and AI stuff...

C for embedded programming and Julia for your data science shit.

Not a data scientist myself, but a former course mate who transferred to the field was made to learn Julia on his first semester at a Data Science MSc at one of the best universities in the UK.

Work with data scientist and the primary languages are R and Python. Soon to move to Julia. For implementation and time efficiency C++ is used. Yet to use Rust in any of our groups I'm aware of.

Why not Ada for your embedded hobby? It was literally designed for embedded and real-time , but for shit like nukes and spaceships. Also a great general purpose language.

It helps to have an actual problem to solve. Real problems also tend to be messier, which is better practice.

Here's a vague picture of what you should be comfortable doing.
- Loading, cleaning and sanity checking datasets. This should include finding the garbage and weird shit in it and deciding what to do about it (any language)
- Visualizing data. R/ggplot is probably the best tool for doing this adhoc. You want to be able to gain intuition about your data and show others
- Making quick reports/summaries about data, rmarkdown is a good choice.
- Linear and logistic regression, various smoothing techniques like loess/spline fits, get comfortable with binning and kernel smoothing (any language)
- Meme learning, gain intuition about how neural nets behave, what useful networks look like, how they fail etc. (Python/Keras). You can try it on simple regression tasks first since it's less intensive and trains fast
- Get your hands dirty with fancier stuff where you need to work with raw Tensorflow/Pytorch. Maybe try some RL, starting with a simple DQN or something

This is in order of usefulness. Basic plotting abilities and cleaning data is the most useful. Most of the time OLS and maybe some tables/plots is enough desu

Rust seems cool, I've been wanting to learn it to use their curses library. github.com/gyscos/Cursive it seems pretty cool.

By sanity check you mean looking for outliers and markers of the data’s overall quality/usability right ? I’ve actually been doing that at work for my ML inbox manager. The email data point strings are fucking all over the place sometimes.

Yes, you have the idea I think. Basically just making sure you aren't trying to form conclusions using garbage data. This is also why you want to make a lot of plots, since you can often visually pick out the junk and suspicious data. It's not just bad data but also bad assumptions that you didn't think about

Oh wow then I’m farther ahead than I thought. Now if I could just snag a damn data science job without a fucking PhD [spoiler] Hopkins MS done this month tho [/spoiler]

finally a quality thread

Attached: dance.jpg (480x480, 62K)

>You might be using a function now only to have it moved to unstable next week.
If you mean, like in the context of libraries, it's true that many have not reached stable status. As for the language, it focuses in stability since the 1.0 version and even keeps some functionality as opt in to keep backwards compatibility

Not in space. Rust is always bloated.

Julia

>So in the interest of usefulness for the long term, I should go with C?
Yes. Rust won't be around very long since Mozilla is dying, whereas C is forever.

>So in the interest of usefulness for the long term, I should go with C?
Absolutely, C is tried and true and applicable in many domains from embedded to high-performance computing.

Disagree. Rust constantly ranks as one of programmers' favorite languages. In school I see many students favor Rust over C. C will probably be around for a long, long time, but I expect Rust to continue to grow even if Mozilla dies.

Mozilla shill campaigns are the only reason you've even heard of Rust. Noticed how lately there's a lot less buzz about it? That's because they cut their gorilla marketing budget.

just because something is favored by humans(codemonkeys) doesnt mean its good when looked at from objective perspective, they only like rust because it holds their hand and everything "just werks" so they can carry on being a codemonkey, while when they program in C their brain starts to hurt due to how hard it is for them.

C is forever
Rust is for cucks

Just because students who don't know any better like Rust, doesn't mean that it is good. And the Stack Overflow most loved language is pretty retarded because small talk was also ranked highly, yet nobody even uses smalltalk anymore.

julia, perhaps.

no, it's because the language is good and does what it claims. of course you wouldn't know never having tried it.

Why would I try it? Rust is extremely difficult to use. You really have to contort your mind into a pretzel to think like the borrow checker.

>Rust is always bloated.
Do you have a source for that?

>Rust is too hard to use, and also too easy.
What?

This is a common misconception from people who haven't learned the concept of lifetimes or simply don't know how to use the language. Either way you don't have the credit to criticize something you've never used. It has many great concepts executed well, with the exception of the restriction of lexical lifetimes (with non-lexical lifetimes available on nightly and soon stable). About the pretzel thing, it's just about understanding the language patterns, as with any language. I've never had any struggle to get it to do what I want minus the first week or two where I was trying to use it like it was C (coming from C), which it isn't. It's a mix of imperative and functional languages, and a healthy dose of its own thing.
Thank you for reading my blog.

also it's not difficult to use per se, just very different from other languages and takes a bit to understand. "wrestling with the borrow checker" doesn't exist unless you're trying to force it to do something stupid

Attached: too hard and too easy.png (1280x1280, 77K)

three replies, can't collect my thoughts at 3am, my bad. you can still force it to do something stupid or not checkable if you just
unsafe {

although you generally should only know this if you know what you're doing

>>> next in range(2) == False
False
>>> next in range(2) == True
False
>>>

No, the borrow checker still applies to unsafe code. What it does allow you to do is to use raw pointers.

The biggest problem I see with Rust is that you can have only have one mutable reference to a value at any one time. So a child object in a design pattern cannot have a reference to its parent. There isn't really any way around with without a lot of Rcs everywhere or resorting to unsafe code.