tuvistavie

I have been using envio for a while, as a simple way to avoid keeping secrets around in plain text. Secrets can be encrypted with a passphrase or a GPG key. Not a silver bullet but better than just keeping everything in a .env file.

https://github.com/humblepenguinn/envio

I think having API keys for some third-party services (whatever LLM provider, for example) in a .env file to be able to easily run the app locally is pretty common. Even if they are dev-only API keys, still not great if they leak.

I've been studying wine and was a bit frustrated with the wine note taking apps around, so I've been building one. It allows to:

- Scan wine labels (it analyzes the label automatically)

- Add structured or unstructured tasting notes

- Create lists (shared or not) to keep wines organized

- View information about the regions/grapes

It's called Cork Club: https://corkclub.app/

Depending on the country, it can truly be. Some of my relatives have money stuck in Lebanon and there is currently not really any way of getting the money out of the country.

In general, I'd say UK visa process and cost are quite terrible, to say the least. However, for the global talent, the harder part is to get endorsement, after which it should be relatively straightforward. A friend of mine recently got his through the research route and the process seems to have been quite smooth. I think it took about a month or so. For reference, he is finishing a PhD in a top US university and has a good amount of peer reviewed research.

I am not sure I would advocate for this but, from Python 3.8, this is an instance where assignment expressions could allow the first code without duplication.

    first(x * y
          for x in nums
          if (y := 2020 - x) in nums and x != y)

> The difference is that what the doctors put so much time into learning can actually be quite useful for their job.

I'd be curious to hear what a doctor would think about that. My intuition would be that, as for almost any exam, a lot of time is spent on things that will not be useful for any other purpose than the exam itself.

Runtime safety and compile time safety are not the same thing. Compile time safety is not a silver bullet but it does protect against quite a few classes of errors.

I think the only possible answer to how much math do you need is that it depends on what you work on. There is a lot of stuff that can be done only using very basic math, that's for sure.

I would tend to agree with the article that math can be quite useful as a general mental model and can often help to find cleaner solutions to some problems.

There are also a lot of applications that require some, often quite specific, knowledge of math: machine learning, cryptography, game engines, to name a few.

As much as I agree with you on all the points, in my case I kind of have to stick with what my research group is using for now.

I'm in the middle of my PhD and switched from printing papers to reading them on my iPad roughly two years ago.

There are some things I miss from paper but overall I found the pros to overweight the cons.

I haven't found that flipping back and forth on iPad is that horrible, to be honest.

Not sure how helpful this will be but I'll share what I've been doing for now. I use the following apps:

* Mendeley (to organize papers)

* PDF Expert (to annotate PDFs)

* GoodNotes (mostly when working out the maths)

My usual workflow is:

* Read through the paper

* Annotate in the paper using Apple pencil as I read through

* Figure out the maths on the iPad when needed

* When I get back to a computer, upload the annotated file to Mendeley and type summary notes in Mendeley

A few things that I like/dislike about iPad when compared to paper.

+ Search for information on the web while reading paper more easily

+ Check notes/annotations quickly from my computer

+ Share notes easily

+ Search notes easily

+ Clean desk =D

- More context switching needed when I need to scramble something

- Mendeley misses some basic features on iOS (e.g. attach PDF to existing paper) so need to context switch with computer at some point after reading the paper

I would say that for 90% of the papers I go through, where I don't dive that deep in the paper, the experience is just as good on iPad. For the 10% of the papers I read where I go in-depth, redo proofs, etc, it's a little more tedious. While it's for sure not perfect, given the above pros, I can live with the cons.

At the end of the day I think it's just a matter of cost. If it's cheaper to let a software fail and simply fix it when it does, there will not be much interest into proving it to be correct. If a failure will likely be vastly more expensive than proving correctness, then proving correctness will make sense. There are simply way less instances of the second category. I think one of the few "new" instances, which might be worth mentioning is smart contract programming, where failures can cause millions of loss and proving correctness is not too expensive.

I am pretty sure we reached this point quite a few years ago. From what I know, most people learning web programming nowadays start with Rails, Express JS or whatever framework of the day they have been recommended, and use the integrated HTTP server for development, I would assume, often without even really worrying about what is actually happening. CGI scripts are definitely not on the list of things to learn there.

The amount of tweets and the variety of languages is actually pretty impressive. https://daniel.perez.sh/misc/notre-dame/

For me English has been working decently on DDG but last time I tried I had a really hard time getting decent results in other languages.

I made a plugin for that. It works well enough for my needs. https://github.com/danhper/fish-fastdir

Changing `INCLUDES = . parser ....` to `INCLUDES = . external parser ...` in the Makefile fixed compilation for me.

I'm curious to know how this is usually handled in the US. What would be the usual process for company B and C to work on the product?

The article seems to be missing what I think is the major reason why Japanese websites are how they are.

I think one of the major factor is how the IT industry works in Japan, and the process to build a website, an application or anything which involves software engineering. A good majority of Japanese websites are not built or controlled by the company, but rather by what they call "System integrators", which they refer to as SIer, and these are quite different from the software/design agency we see in the US or in Europe. The usual flow is something like

- Company A wants to build a website - Company A talks to the SI company B - Company A and B spend hundreds of hours doing meetings - Company B's "System Engineers" write tons of specifications on Excel - Company B asks company C to actually code the specification written on Excel - Company C may then again delegate part of the system to company D, and this can a few more levels down depending on the size of the project

As nobody actually does the "building the service" part in company A or B, they usually do not have any designers, and therefore cannot give enough design related information to the company actually implementing the software. However, the only incentive for company C being to get paid by company B, the quality of the work or the UI/UX does not really matter that much as long as it fulfills all the specifications written on Excel.

Now, some companies are starting to see that this model is quite flawed, and either recruiting engineers and designers of their own (e.g Recruit, a huge company in Japan owning many different webservices [1], has put a lot of efforts recruiting engineers and designers these past years). Some other companies start choosing companies which are closer to the software/design agency model - companies who actually do the engineering and designing part - but the SI model is still prevalent [2].

[1]: http://www.recruit.jp/service/

[2]: https://www.jisa.or.jp/Portals/0/report/basic2015.pdf?201602... (p14)

It is also worth noting that the ecosystem around fish is quite developed, making it easy to get easy integration and completions for most well-known tools.

oh-my-fish [1] plugins is a good place to see (part of) what is available

[1]: https://github.com/oh-my-fish

The web based configuration is completely optional. Editing dotfiles works just as well. I have been using fish for quite a while but never use the web interface (I didn't even remember it existed)

Up to what point can the output be controlled? Can complex conditions be created? e.g. a lake with a mountain background during the evening

This looks interesting, but the last commit is 5 months ago. Is the project still in active development?

Yes, I don't think this is an official number though. It is almost sufficient (according to specialized lawyers) on its own but not absolutely necessary depending on the person degree, skills and plenty of other things.

edit: After checking a relevant Japan ministry of justice webpage [1], 5m yen is given as an indicator, which is why I suppose it is the value given by most lawyers.

[1]: http://www.moj.go.jp/nyuukokukanri/kouhou/nyukan_nyukan20.ht...

You just install the new Erlang VM, install Elixir 1.3, and that's it! Elixir 1.3 is compatible with Erlang 19, and will by default use the Erlang installation available on the path, so nothing to do in particular.

If you want an easy way to install both, you can check asdf [1].

[1]: https://github.com/asdf-vm/asdf

I also published a blog post[1] about Elixir 1.3 a little while ago, which is partly complementary to the official one.

[1]: http://tuvistavie.com/2016/elixir-1-3/

If you look at the console, you can see the AJAX request fails with 500, and says it cannot connect the DB, so it's not a browser or JS issue.

This link seems to work for now.

https://archive.is/t9oKw

It should now show the post even without JS, thanks!

Oh, thanks, I was not aware of that. I'll fix it!

Exceptions are not discouraged, using them for flow control is. There are I think a few reasons why exceptions are a being a little frowned upon.

The first one is that usually we do not want to rescue them, the let it crash philosophy. If an error happens, the the process will crash, it will be restarted, the error will be logged, and everyone will be happy.

In the case we really do want to handle an error, we can usually just use `case` or `with`, which are simpler, avoids to rescuing something we did not expect, as well as some pitfalls, for example the fact that recursive calls inside a `try` cannot be optimized to be tail-recursive, which can be an issue depending on the case.

However, I think it is fine to use exceptions if it can avoid deeply nested code, which was probably your case.