fantispug

Regarding quotes, they're optional (e.g. when you need a comma, leading whitespace, or newline). With arguments by position possible I guess colons have to be quoted too.

It's not clear to me that it's possible to convert this to a standard CSV; it can't guess the header and guessing whether a column contains units (consistent units?) is asking for trouble.

More pragmatically I can't share these with other people because they're almost like a csv, but incompatible.

It's great to try to make CSV more readable (I like the leading whitespace, but it'd be finicky to maintain with simple text editors), but not worth the technical risk of format confusion.

It's good to see an article about Firefox enhancing privacy, rather than for backdoor installing plugins for Mr Robot, integrating closed source Pocket (the server is still closed source despite the Mozilla acquisition), or opting in sending browsing history to commercial companies like Cliqz without explicit user consent.

Mozilla has done incredibly well to have Firefox survive at all against competition from Microsoft and Google, and has undoubtedly had to make some tradeoffs (such as DRM), but it's at its best when it sticks to its principles.

A 3% increase in speed is a miniscule improvement. Emacs has a small dedicated group of maintainers, increasing the maintenance burden will stop other developements (such as the recent addition of async which is a much bigger performance issue). If emacs is losing users I would guess it is because to make it an IDE takes more configuration, and has more issues than competing products.

I think the primary contributor stopped work on it, no one else took over, and most users don't perceive its benefits outweigh its switching costs.

I don't want to remember more of what I read; I want to have access to a breadth and depth of ideas I can justify with evidence.

Repetition and flashcards will help you remember the content, but it won't help you understand it. That's only done by actively engaging with the content and connecting it to and comparing it with other facts and ideas.

The summarising, keeping lists of questions, and writeups will help you understand the content, and I think is the only valuable part of this process. Why rote memorise when you have lovely writeups you can refer back to.

I find Luhmann's Zettelkasten method, as described in 'How to Take Smart Notes' more persuasive. As you read make bibliographic notes in your own words (on page X it says Y), store these in one place for everything you read. Also note down key ideas as you read with cross references to the bibliographic notes, and to other key idea notes that are relevant; store all these notes in another place. When you're filing a key idea have a look for similar ideas already noted; is this the same? Supporting? Contradictory? These questions help engage with the content. Over a lifetime you can amass a treasure chest of ideas that you can refer back to at your leisure, as Luhmann did.

I think there's undue emphasis on "fundamental". Modelling complex systems is important in actually making real world predictions. Condensed matter physics, as one example, is an area that is growing and has a plethora practical implications.

By similar logic you could argue all physical units are abstractions, which I guess they are. They are very useful in creating a simple accurate predictive model of things we observe on many scales. What's the utility of a distinction between existence and abstraction?

I'm not sure about antivirus, but magit forks git a ton of times which is really slow on windows. You are often better off running it from inside a linux VM.

You could cobble most of this together.

You could probably get notifications using org-alert.

Emacs does a reasonable job parsing most html including emails to text, but occasionally you may need to view in browser if it's very html heavy. You can compose html emails using org mode syntax with org-mime.

PDFs are rendered as images. So you have limited emacs functionality, but it does a good job rendering PDFs. Doubt you can do forms.

Because there are lots of businesses that don't have a booking API and don't see the need for one, or can't afford one. This kind of technology allows interaction with them, because it's easier to interact on a common transport protocol than to expect everyone to change to your preferred one. That being said I feel like it won't be long until this tech is used for scamming, phishing and pranks.

I'm traditionally a textbook person too, but I really like fast.ai. You get to see how to tinker with things in real time (which is often clunky in a textbook), and there's a lot of informal folklore that people don't normally write in academic textbooks. If you're dead set against video you could just work through the notebooks yourself and read the referenced papers on the website.

Also R and MATLAB/octave are array based languages too. You may consider Fortran one too. But none of them have things like dyads.

How hard would it be to follow the course using QGIS? Is it about the principles, or specific ArcGIS features? I haven't found as good courses in QGIS, but I have no interest in learning ArcGIS

There are lots of interesting problems with interacting with external underdocumented systems.

I find edit and continue really useful for making something worm with these.

Are these out of the reach of "professional programmers"? Can they only work on systems with fully specified models, with exacting requirements?

But would you be sure you've actually fixed the bug? Perhaps your edit changes the state that would be reached by the continue (e.g. bug is on first iteration of a loop, and your edit inadvertantly changes the initialisation).

I think it's useful for fleshing out a bug and could save time if there's another issue downstream, but I wouldn't count it as solved until it has been tested on a fresh run.

Yeah, just comint with elpy. There are some rough edges; I can't input multiline in the comint buffer (but can send it), and gives an error on the very first command, but otherwise works well.

I use this kind of workflow all the time in Emacs. I write code in one window and have a Jupyter REPL in the other and send code to the REPL to test things live as I'm coding.

I'll have "pdb" set up in Jupyter REPL so it drops into a debugger when I have an error with a function.

In the case of a long running function I want to debug (like the video example at the end) I'll set local variables with the same names as the variables of the function and then execute the function line-by-line/chunk-by-chunk.

The only problem is losing track of global state, but the same thing can happen in Jupyter notebooks.

This type of workflow is really common in Lisp and R.

If I want to integrate documentation and code, I'll use org-babel or R Markdown (which does work with Python).

Math is a clean room where you don't need to worry about the concrete representation. Often the details of the representation and how they connect are more to do with human psychology (keeping things understandable) than with algorithmic heuristics.

On https sites there's not a lot ISPs can track without breaking encryption. With shared IPs they may not even know the domain for certain (although as IPv6 takes off it will be easier to map IP to domain).

Like Grigori Perelman did?

"If You Can" by William J Bernstein.

It gives a simple conservative investing strategy, and refers to other great books for the details.

Available here: https://www.etf.com/docs/IfYouCan.pdf

I really like the book “Concrete Mathematics”. It might be a little hard going without much maths background, but it is filled with these kinds of tricks.

It depends on how you define the summation of infinite series. With the standard convergence type definitions you are correct. But it is possible to define this sum in a consistent way (e.g. Ramanujan summation or Riemann Zeta analytic continuation) as shown in Hardy's “Divergent Series”. The cost is that they have properties like rearranging the order of the terms gives a different result. Apparently this sum can come up in Quantum Field Theory when calculating vacuum force between two conducting plates.

The amount of censorship varies by province; I wouldn't be surprised if it is easier in Shanghai than in other parts of China.

A lot of science is done with GPUs ... in FORTRAN and C++. I believe an n body simulation in GPUs is what started the idea of using GPU for general computation.

I would be extremely surprised if you could get similar or better predictions for the same amount of computation from an off the shelf CNN than from a carefully tuned physical model. (I would love to see counterexamples). Even then I would question how well it extrapolates; you generally have a very good idea of where your physics simulation will break down.

I think your friend is right; the physics community can't afford to throw away as much code as the tech community. I wouldn't spend years building a simulation in tensorflow because it will likely be obsolete before I finished (leading to the same problems as FORTRAN but increasing the amount of dependencies).

In any case, if it works well enough it's not going to be rewritten.

Eventually ML will become part of physics simulations, but I don't think there will be easy wins in these well developed areas.

Tools won't make people care, but they can help produce consistent documents.

Atlassian Confluence is a horrible recommendation; it has few tools for typesetting, PDF export is very mediocre and hard to control (there is a plugin that allows you to control pagination), and I once found something that was impossible to produce in its markup (my workaround was to insert a zero-width character and hope no one copied it into a terminal).

Pollen is a Racket language, and gets parsed into an AST and evaluated. You can programmatically generate correct markup using all of Racket.

Org Babel is more about evaluating code snippets in a variety of languages. Even if you can evaluate to produce org markup that's processed it doesn't have the same level of structural integration.

KaTeX suffers the same issues as MathJax; it has to render some subset of Math LaTeX to something web browsers can render. We now have two standards. All the CSS issues in the article apply as much to KaTeX as anything else.

Full TeX is not a good fit for the web as it's designed to typeset paginated documents at a size known at write time. You would standardise on some subset of Math mode LaTeX like MathJax does.

The challenge is then picking the subset of LaTeX. Then maybe someday someone would write a web-LaTeX preprocessor with macros and the like.

I think Kodi has a decent shot at getting there - there is now a fledgling Netflix plugin. A big step towards providing content to the major streaming services (and local content) through a customisable UI.