z1mm32m4n

If it was just me, I’d use plain text files like people are suggesting in this thread. In particular, if you want to be able to track and do retrospectives of what’s been done, consider using jrnl[0] to log what you’ve done.

For small teams, I really like Dropbox Paper. It’s better than text files here because it’s real-time collaborative, but retains nearly all of the flexibility. It supports Markdown syntax, checkboxes, etc. You can tag members of your team, comment in the margins, and link to one doc quickly from another. For small teams that don’t need a heavyweight process, Dropbox Paper fills fits my needs here rather well.

[0] http://jrnl.sh

With a bit of twiddling you can get Travis CI to publish to pypi on successful master builds:

https://docs.travis-ci.com/user/deployment/pypi/

It’s more than just HM type inference. This relies on particular on ad-hoc polymorphism (many languages with HM type inference only have parametric polymorphism).

Yeah, I realized that after I’d already published it!

It’s still a listing of “hot” files in some sense though.

This library looks really cool!

Frequently I'll have a data set (list of transactions over time, log of analytics events to a site, etc.) that I want to visualize. It usually involves slicing the data in multiple ways with a handful of queries.

It'd be really cool if I could load up a CSV file / SQLite database per document and embed charts that visualize queries on that data. The goal would be to keep the data, visualizations, and text as close together as possible.

Short of this feature being available, I can only do something like:

- write some SQLite queries

- write a quick script to run each query, and save the results to a file (CSV/JSON)

- reference each individual file from the Idyll document

Again, really cool project!

I’m a huge fan of csvkit, which includes a similar utility along with lots more:

http://csvkit.readthedocs.io/en/1.0.2/scripts/csvsort.html

Some of my favorites tools it includes are csvsql and csvlook.

What is your favorite notation for merge boundaries?

What happens when the stuff like the “exclusion zone” and the war from 2020–2025 come true...? ¯\_(ツ)_/¯

I’m a huge fan of Practical Typography by Matthew Butterick.

- If you only read it linearly it gives you the most crucial points early up front.

- It does an excellent job of linking between and to relevant sections. The most natural way to read the book is to read it non-linearly.

- It balances depth and brevity.

https://practicaltypography.com

I keep my build output on watch in a tab and have touched tell macOS to send me a notification when it notices a certain text pattern. It’s especially nice for things like Jekyll rebuilds.

I've found that fzf has replaced all uses of find for me except in scripts. fzf has the benefits of being bound to a single key binding and showing me results as I type, rather than after the command runs.

The idea of "programming paradigms" is not a useful way to talk about programming language design.

> The trouble with programming paradigms is that it is rather difficult to say what one is, or how we know we have a new one. Without precise definitions, nothing precise can be said, and no conclusions can be drawn, either retrospectively or prospectively, about language design. > > What, if anything, is a programming paradigm? [0]

Luckily, we've studied programming languages and their design rigorously for decades, and we already have a rich, common language for discussion the design space of programming languages: type theory.

It sounds intimidating: "theory" is often general abstract nonsense that's only useful in academic research, etc., etc. But that's not the case at all. "Type theory" is really just a really useful way to understand individual features of a programming language, and how they compose with one another.

[0]: http://www.cambridgeblog.org/2017/05/what-if-anything-is-a-p...

I actually aliased :q to clear:

https://github.com/jez/dotfiles/blob/master/util/aliases.sh#...

I also have clera, lcear, and lcera -> clear, and :tabe -> vim.

This also opens up the door to more secure payments. The "basic card" handler is one where the browser might just store your raw card number. But you can imagine that your bank might implement a payment handler that requires you to enter a 2fa code before using your card.

When it comes down to it, a credit card number is kind of serving double as a username and password for online payments right now. This new API has the potential to significantly improve upon the security of raw PANs.

As someone who's never used Solaris or looked into its merits I'm curious: can someone comment on why all the nostalgia for Solaris?

The confusion here is because Pest is not, in fact, a parser. It's a parser generator: you can use it to generate parsers (maybe even a parser for Rust), but it is not in itself a parser.

A better title would be "Pest - Fast, modern parser generator for Rust".

One cool thing is that rather than the parser generation being a standalone tool, it's written using Rust's macro system. Normal parser generators use some sort of command line tool to generate say C code which can then be used like any other library. Here, there's no need for generated code, because the Rust macro system generates it on the fly.

That being said, think about the other lines in the accountants books that could be better funded if universities didn't have to pay for journal subscriptions. That funding could go towards hiring more professors, paying professors better, hiring more research assistants, outfitting research labs better, etc.

If we aren't paying researchers for peer review, the journal pay wall is just a net loss in productivity. It's just one more useless middleman.

This is a great comment outlining some of Haskell's strengths. Definitely, ADTs should exist in every language claiming their static type system as a feature.

Just one thing that stands out to me:

> "Anything can be anything or sometimes nil" is a hard pill to swallow once you've used Haskell.

In a language like Java yes, nearly every type is inhabited by null. In fairness, a similar problem exists in Haskell: every type is inhabited by "bottom" which is the computation that never terminates. This is a side effect of being lazy by default.

Oh wow this is going to be a joy to read, thanks! Only a couple pages in and it already looks well-written and thorough.

Also there's this: "This paper is literate Haskell and our examples compile under GHC 8.0." A 26 page, typeset paper is certainly the longest example of a literate Haskell program I've come across! Wow.

I would guess they view these sorts of topics as "gateway drugs" into American culture, culminating with free speech and open criticism.

> A new, more type-safe type reflection mechanism

Does this mean GHC does not erase types at runtime? Or perhaps what do they mean by "reflection" here; I only know it in the context of Java, where it more or less felt like an anti-pattern.

I have a separate bank account for Venmo that I keep capped at a few hundred dollars. Getting robbed a few hundred is much better than a few thousand, and for the convenience of Venmo (especially on a college campus) it's a fine risk for me.

Surprised to see that this doesn't use ncurses at all. I was really hoping to see something that brought the painlessness of using React to building an ncurses textual interface.

Seeing that it doesn't use ncurses, I'm suspicious of how it does re-draws. I'd imagine the naive thing of just redrawing every bit of text on the screen for every reactive event would work, but be pretty slow. Of course, if they're doing something smarter than this, I'd be interested to hear how it's done.

> Some parts of the city are really beautiful and nice places to be, lots of great parks and so on

It's hard to understate this point. Compared with San Francisco, Pittsburgh is much more visibly green. There are trees everywhere, grassy areas abound, and the city itself is nestled in green hills.

San Francisco is full of concrete. The Bay Area is still really brown from the recent droughts. There are certainly people who can overlook this and live perfectly contently. But in Pittsburgh, I don't have to give up the greenery for a city life.

Ah, didn't realize the original question was limited to comments on dynamic typing. Regardless, that's a clever article, and an interesting tradeoff.

There's no amount of union types that will save you if you want to write a polymorphic, type safe map/filter/reduce function. These functions need to be generic over containers.

At best, with this union type hack what you'll recover is similar to "ad hoc" polymorphism, not true parametric polymorphism.

That's not true. When the language is lazy, you can't give a different type to one expression that's lazy and one expression that's strict. You can write hacks into the language that tell the compiler to evaluate certain expressions strictly, but you can't capture this in the type system when the language is lazy by default. On the other hand, this is perfectly possible in a strict language.

I've not found an elegant way to express in Haskell what can be expressed trivially with modules and functors in SML/OCaml.

This also refers to text with "display: none" and "opacity: 0", which used to be (still is?) a way to trick search engines into ranking your site higher.

I'm sure I'm biased, but I'm a huge fan of how they taught our first two semesters where I went to school. Semester 1 freshman year was imperative programming in C (learning pointers, bits, the stack and heap, memory, ...). Semester 2 was functional programming in SML (learning recursion, types, function composition, formal reasoning, ...).

When it comes to other programming language features, there are few that can't be understood as some combination of imperative and functional features. Introducing them freshman year, students take these lessons with them to every subsequent language they learn.