hoosieree

Notebooks aren't very git-friendly, so in practice you rarely know which version produced the paper.

The fact you can run notebook cells out-of-order exacerbates this problem. Not only do you not know what version the entire file was, you also don't know in what order or how many times each cell within the file executed in order to produce the plots you see in the paper.

This isn't to discount the improvement in UX that you get from notebooks compared to my preferred alternative (emacs with org-mode). Maybe I'm just bitter that the ipynb format exists at all. If notebooks were just a UX layered on top of emacs+org-mode, that would fix most of the core issues.

If you're lucky, someone releases code+data associated with their published paper. If you're really lucky, that code and data is in the same state as it was in the published paper. If you're really really lucky, someone besides the author can get it to run.

If you can consistently locate and run academic publication code without direct help from the authors, you are The Chosen One.

[edit]

In seriousness, reproducibility is also my biggest concern. Scientific/academic publishing could do a lot better than rendering pretty static documents - we can provide the data, code, version control, and build processes which produced the paper so anyone can reproduce what they see in the paper. AND we could host them together so they're bidirectionally linked, to facilitate other scientists building on top of our work.

That could be our future, with the right incentive structures in place.

dang it!

Not working yet, but I'm trying to make a K-like language targeting CPU+GPU (mostly for machine learning): https://github.com/hoosierEE/element

At this point it's just a parser and a dream, so don't expect much.

REPL-driven development keeps me in the flow. I can write (and test) multiple different approaches to a problem in J or K before I can finish typing the first approach in C++. And that's not even counting time and context switching costs of compiling and running the C++ code.

Lisps and Smalltalk also have repl-oriented development, but they're verbose. Even tab-selecting a Copilot generated autocomplete takes more keystrokes than some array language programs.

Disclaimer: I'm no expert, just an enthusiast.

For me, the feeling of being well-designed or expertly crafted is what sets the array languages apart. Learning one concept often (intuitively, for me at least) extends to many other parts of the language.

For example, in Q the comma operator concatenates arrays:

    q) 1 2 , 3 4 5  // returns 1 2 3 4 5

...but it also merges dictionaries (duplicated key `x gets the new value):

    q) (`a`b`c!1 2 3),`c`d!4 5
    a| 1
    b| 2
    c| 4
    d| 5

...and also joins tables by row. Sure this is "just" operator overloading, but it's so deeply ingrained in the language it doesn't feel jarring or bolted-on like in other languages.

Building a program is less about crafting bespoke abstractions and more about using the existing building blocks, which leads to a semantic uniformity that's rare to find in other languages. Or at least, it's easier to get your job done using only built-in features and not have to resort to custom abstractions.

1. buy real estate in a billboard-infested city

2. ban billboards

3. sell

You kids with your newfangled "@" and "." emails. Looks like line noise. What is this, APL?

The xenophobic origins of zoning law is a cautionary tale for today. "I got mine, screw the rest of you"... but sooner or later "your" tribe becomes one of the "other" tribes.

Lots of this attitude in society still, guess we'll never learn.

Starting your own business has always been and will always be risky, but W2 jobs aren't as safe as they once were.

How about starting a "lifestyle" business that doesn't need to grow but is sustainable, and that lets you solve a real need for real people while providing stable income?

I feel like this is a pretty common opinion among HN comments, and yet the vast majority of interviews follow the known-bad pattern instead.

Are HN commenters simply too rare to make a dent in the larger hiring landscape, or are they not walking the talk?

As an amateur woodworker, this is not changing my belief that a $50 USB microscope is one of the most expensive things a hobbyist can buy.

mascot: a python, with braces

The slow food movement is really getting out of hand.

    All I word is

Which keyboard did you use to type this message? :)

Murphy's law for data viz:

If a plot can mislead, it will.

I agree diffusion makes more sense for optimizing code-like things. The tricky part is coming up with a reasonable set of "add noise" transformations.

"Explain" is a variation of "what do you think about", so you get similar results.

https://news.ycombinator.com/item?id=40723601

No. Remove the "explain" or "what do you think" or "think critically about" types of phrases from the prompt and you get this kind of thing:

My prompt:

    Joe drove Sue to the university. Afterwards, he drove home again and drank tea with her in the kitchen.

GPT-4o Response:

    Your sentence is correct, but for a slightly smoother flow, you could rephrase it as: Joe drove Sue to the university. Afterwards, he returned home and drank tea with her in the kitchen.

It will never "notice" anything off about the input unless you ask it to. I'm consistently impressed how many supposedly tech-savvy people believe GPTs turn into magic orbs if you make them big enough.

    > Surely nothing in the prompt directly triggered the word "inconsistency".

The prompt is (implicitly) asking to find inconsistencies ("what do you think about") within some statements of fact. Many variations of "find problems in the text" are part of its training set.

Remove the "what do you think about" and the model doesn't find inconsistencies.

Or keep it, but make the following text more consistent, and watch it continue to find inconsistencies (which don't exist).

The more Python I write, the more I feel that "from foo import name1,name2,nameN" is The Way. Yes it's more verbose. Yes it loses any benefits of namespaces. However it encourages you to focus on your actual problem rather than hypothetical problems you might have someday, and the namespace clashes might have a positive unintended consequence of making you realize you don't actually need that other library after all.

Do you have any more specifics about these limitations? I'm considering trying Taichi for a project because it seems to be GPU vendor agnostic (unlike CuPy).

My dissertation worked on a similar problem. I used obfuscation to build a large dataset from a small set of ground-truth functions. Then built a model to classify unseen obfuscated binary code to the nearest of the known functions.

The application I had in mind during the research was anti-malware static analysis, but optimization is really just the flipside of obfuscation. Something I'd like to try in the future is a diffusion model that treats obfuscation as "noise" to be removed.

One thing I learned is that optimizing compilers produce very regular output. After normalizing addresses, the "vocabulary" size of basic blocks ends up pretty small, like ~2000 tokens. Certain "phrases" correlate with the original source code's semantics regardless of how much obfuscation you add on top.

I started with J but now prefer K and I'm writing an interpreter for a K-like language in my spare time for fun.

I'd say the minimal syntax isn't just a gimmick, because it really does help with mentally chunking phrases/idioms to a degree that's not possible when the same phrases are multiple lines long. Terseness also makes it physically faster to write the same thing, which encourages interactive experimentation much more than other languages.

These are small things, but taken together you get an experience that's more than the sum of its parts.

A lot of folks seem to tolerate K syntax because K jobs pay well. (Supposedly. I've never seen a super-high paying K job in real life.) But I actually like the K syntax because it helps organize my problem solving, and it gets out of the way during experimentation time. To me it's like NumPy/Pandas but better designed and without all the ceremonial boilerplate.

Come check out some of the array languages[1,2,3], or perhaps the retro-computing comfy vibes of a system like Decker[4]. Some of us still appreciate code as poetry.

[1]: https://mlochbaum.github.io/BQN/

[2]: https://www.uiua.org/

[3]: https://code.kx.com/q/learn/tour/

[4]: https://beyondloom.com/decker/tour.html

Whenever HIBP sends me a notice I just think "oh well, add it to the pile". By this point I just assume any info I share with any company WILL be leaked eventually. Which is why I'd like to see an equivalent of the GDPR in the US, because companies won't do the right thing (collect the minimum necessary) unless they're legally forced to.

My favorite is when a credit bureau like Experian leaks your info and offers free monitoring as compensation - but you have to give them your info again to get the free monitoring.

Same here. But knowing my ISP, it'll change throughout the day, sometimes by quite a lot.

Headline says 1/3 of those 700k are on food stamps. Would an extra $900/year be enough?

It looks like the xkcd theme for matplotlib[1]. But I agree the waves are too extreme.

[1]: https://matplotlib.org/stable/gallery/showcase/xkcd.html#sph...

    I assume it gets easy to read once you practiced it a bunch

Yup, but for me at least, the learning curve is far gentler than a supposedly simple language like C or Go. After using C professionally for 12 years I still have to look up operator precedence or use cdecl from time to time. Meanwhile I feel like I can store all of K in my head with room to spare.