I just want to point out that Jupyter and ipynb are separate things.
ipynb files are shit, but Jupyter doesn't have to be. For example, VS Code supports Jupyter without ipynb. This way you can end up with files which, unlike ipynb, are valid in the target language (e.g. python, julia) AND play nice with git, but are still interactive thanks to Jupyter.
In fact, the above realization - that there are IDEs that support Jupyter without ipynb - has been the biggest boost to my productivity in 2021. This came in the form of being able to version my interactive jupyter files.
In fact Jupyter is just a mashup of Julia, Python, and R (no TeX). The commenter may have been thinking of Pluto¹, which is Julia-only but a big improvement over Jupyter.
1 ‘An introduction to pluto’. LWN. Available from: https://lwn.net/Articles/835930/
yes, jupyter is more or less a generalization of ipython, which has been around since 2001. the notebook aspects and language agnostic parts were split off to target python-like languages (julia and R), while ipython became a python kernel for jupyter (like irkernel and ijulia).
I'm interested in this, but I'm doing something wrong.
On the one hand, I've downloaded AnkiDroid and played with it a bit. But I have the impression that just "seeing" the card isn't helping me. I need to be forced to write down the answer.
On the other hand, I've struggled to understand what "kind" of things should go in to a card. For example, verbs: I'm learning a language that has a complex verb conjugation structure. What I really need is to study the conjugation table. But instead the usual cards I download just ask the infinive form, and then display the conjugation table in the back - I'm not going to sit down and study the conjugation table when I'm swiping cards. When I sit down and study I do without cards, so I don't see the benefit...?
1. Definitely use Cloze cards. These allow you to highlight a section of text which you have to type in order to pass the card. They are much more effective than regular flash cards, especially for foreign languages (or anything that requires accurate spelling or precision typing, e.g. code syntax.)
2. Try to make the cards into real-world examples. For instance, don't add the conjugation table, create example sentences for each of the conjugations and make each one a card. For foreign languages, I try to add audio to my flashcards, too.
3. Always make your own cards. Downloading premade decks never works and you miss part of the learning process.
4. For things that don't necessarily lend themselves to being on a flashcard, don't just write the information. Try to frame it in terms of a question and/or in a form that mimics the context in which you'd use the information.
For example, let's say you want to memorize the periodic table. Don't just write:
Carbon - Atomic Number: 6, Chemical Symbol: C, etc.
Instead, create cards with questions like:
What is the sixth element on the periodic table?, Is carbon before or after nitrogen?, What element has the chemical symbol C? and so on.
The more "viewpoints" you have of the topic, the better. I've found this to be a solid approach for virtually any topic.
In my experience it works just fine. For example, using a geography deck to learn the location, flag, capital city, etc. of every country in the world. It also worked well when I taught my kids the multiplication table, the NATO phonetic alphabet, and so on.
> To create a cloze deletion note, select the Cloze note type, and type some text into the "Text" field. Then drag the mouse over the text you want to hide to select it, and click the [… ]
Select the Cloze note type, where exactly? I've searched both AnkiDroid and AnkiWeb (I was thinking that maybe I could creat cards from my computer and use them on my phone) and I can't find any button to make a note a "Cloze note".
Sorry I have actually never used AnkiDroid. I think it's just a mobile app for Anki on Android? If it's like the iOS one, you can create Cloze cards from it.
When you create a card, it should say Card Type or Type at the top. By default, this is on Basic. Click it and you can switch to Cloze. Then highlight the text and click the [...] icon in the toolbar.
If you bought an NFT, it's more likely you bought an address that points to a JPEG, not the JPEG itself. Of course you can save the JPEG locally just like any other JPEG unrelated to NFTs.
How did they buy the address? In what sense do they own the address? They don't own the domain, do they? And can't I just copy & paste the address myself, so I own it to?
I don’t understand any of these comments. Discover has two meanings. Unexpected or within the course of a search. We discover oil and mineral deposits all the time. We don’t usually say “You discovered more lithium? Big deal. Been done before”
While it may not be mind blowing, each source of water discovered makes some kind of Martian base more feasible so it is of interest to some
If new sources of water don’t interest you, that’s fine. But it is still within the definition of discovery
Question is when will someone invest in a mission for something that actually does something with it that is not measuring its existence with remote sensors.
They sorted the results by speed of 1st run. For a language like Julia, which is JIT-compiled, that's not a fair comparison, considering that you compile once and run millions of times.
Note also that Julia would be number 1 in almost all of those benchmarks if you were to rank by speed of second run (as expected...). It's funny because once you notice it those benchmarks are basically an ad for Julia.
EDIT: Also..... lets think critically about some of the entries there. Most of them are languages, but then you have things like Arrow, which is a data format, Spark, which is an engine, ClickHouse and DuckDB are databases. The databases (and spark) will have to read from disk. They have no chance of competing with anything that's reading from ram, no matter how slow it is. They were built for different purposes. These are borderline meaningless comparisons.
- On advanced query: 3rd, 6th, 6th, 4th (up 1), - (out of memory).
> The databases (and spark) will have to read from disk. They have no chance of competing with anything that's reading from ram, no matter how slow it is.
Not true. Upon quick peek on the bench code, ClickHouse and Spark use in-memory table. I assume other engines too.
Note that the compile times of julia are not included in the benchmarks. If you read the website, you'd seen that the grapsh show the first (excluding the compilation) and the second run (with hot cache).
Also in the second run, julia is not the fastest. Julia would not be faster than Rust, its got a garbage collector. This is what you see in the join benchmarks that really push the allocator.
Next to that, the databases run in in-memory mode, so there is not disk overhead. Spark is slower because JVM + row-wise data.
> Note that the compile times of julia are not included in the benchmarks. If you read the website, you'd seen that the grapsh show the first (excluding the compilation) and the second run (with hot cache).
Here's my view: The author of that page has commented here on HN; If my claim was so outrageously wrong as you claim, he would've corrected it.
as mentioned in that thread, GC and strings, or especially a combination of the two, can be very much a downer in terms of julia performance. That's actually pretty surprising since strings are often as important if not more important than numbers for a lot of data processing needs.
I'd also say in terms of compilation time, some autocaching layer outside of precompilation would do wonders.
Agree .. and I was looking for an option to sort by second run.
One trick I've tried to some effect is to run jl code on a smaller data sizes so the compilation gets done and then repeat on the large one so it doesn't get interrupted by compilation. Not sure if this is a recommended approach. Benchmarking Julia is a pain for this reason - compilation always gets mixed up with runtime. But it hasn't prevented me from using it interactively. Pretty happy with it actually.
Not really. They are designed to showcase a common use case across multiple technologies.
The beauty of this benchmark is that there is a hardware limit included so that it forces you to create novel solutions to perform well.
>Note also that Julia would be number 1 in almost all of those benchmarks if you were to rank by speed of second run (as expected...). It's funny because once you notice it those benchmarks are basically an ad for Julia.
Not sure where you're getting that but even on second run Julia doesn't really compete with DT/Polars
It's obvious that you're promoting duck eggs at the expense of, say, chicken eggs or quail eggs or even ostrich eggs. Maybe you could tone that down a bit.
> considering that you compile once and run millions of times.
If you’re writing data pipelines then yes, but a lot of Pandas users use it interactivity. As much as I’d rather use Julia, the last time I tried it I found myself waiting for computation far more often than with a Jupyter/Python workflow.
Give it another try. They've improved the first run times quite a bit over the last few versions. Package precompilation has gotten way better as well.
In Julia there's something better, called Tables.jl. It's not exactly an API for dataframes (what would be point the of that? You don't need many implementations of dataframes, you just need one great one). Instead it's an API for table-shaped data. Dataframes are containers for table-shaped data.
