archevel

I believe you are thinking about Javalin

https://javalin.io/news/javalin-5.0.0-stable.html

I think the argument is more that this tool by virtue of being easily accessible creates more malicious actors. Similar to how most people wouldn't steal a locked bike, but a larger portion would steal an unlocked one. It isn't that much harder to steal a locked bike vs an unlocked one, but the threshold is just a tiny bit higher so more people will attempt it. Conversely this tool lowers the threshold for stalking, so more people, who otherwise wouldn't, will use it maliciously. That isn't the fault of the tool or its developers, but it is something to be aware of when building any tool. When you release it, it may get abused by people for bad purposes.

I built something related to this for our webapp. Most of the text in the app is in a language specific "key to text" map that is loaded at runtime. I made a bookmarklet that switched the language into a debug mode where the keys mapped to a "<file>:<language-variants>:<Key>". You could switch to this "mode" with a simple keypress. User then highlighted the key they wanted to change, pressed another key-combo and was presented with the different translations and could change them (and switch back to normal mode for a preview). Lastly they could generate a PR with the changes they wanted and a Dev could make sure the strings worked (e.g. validating they had not removed a needed placeholder etc). All in all pretty nifty tool.

I agree, but I think you need hope in order to be happy. I.e. happiness is the combination of high hopes and low expectations.

Without high hopes you could just be anticipating things to get worse which tends to lead to anxiety and just a general glum outlook on life. Hoping things will be better tomorrow, but expecting things to get worse is a subtle but important mindset shift.

Found a completely good one!

"Elon Musk's advice on success"

Bad: 0.0000 - Good: 1.0000

If all else is equal, then additional dependencies are a bad thing. Otherwise the only reason to not depend on everything would be code size... And if it's a compiled language with even just a minimum of optimizations then even that wouldn't be an issue.

As with most things - it is a trade-off.

Wouldn't the fact that if they are ok with you working on FOSS protect you? If you have the source you are free to modify it to you hearts content, right?

Would creating a GPL or BSD licensed project and then contribute to that work (in case the employer allows work on FOSS)? Then one would presumably be free to start a business using that software after quitting. Also if it's BSD licensed there's nothing preventing one from close sourcing the stuff after quitting. Of course the code would potentially already be out in the world and used if it's in a public repo...

IIRC RNA is made up mostly of the same nucleic acids as DNA. T (something something) is replaced by Uracil. The main difference is that DNA is double stranded whereas RNA is single stranded. Since mRNA uses three acids to represent one of the amino acids that make up the proteins it encodes, and there is a finite amount of amino acids, this means no new proteins are encoded if you add more "letters" to DNA/RNA.

Possibly the RNA could have some secondary function in the folding of the protein or as a complex inside it...

Edit: spelling

One thing I think is missing from the current html spec is having a src attribute on select tags. Would be nice to be able to not have to define the options directly on a page and instead serve them up dynamically. Not a big problem off course, but it seems like something that is missing.

I like to sum this sentiment up as:

"One day even Socrates will be forgotten."

That you hold a certain value is logically true as long as you actually hold that value. There is no belief necessary in that case. _Why_ you believe it, i.e. the justification for that belief would need to be empirically grounded if I understand the article correctly. That seems a tall order.

Further, isn't even the scientific method at its core also based on certain beliefs about the world for which there is no empirical basis? Not that that would make it any less valuable as a tool for understanding the world.

The crux of the matter is what should constitute sufficient evidence. Is the same level of evidence required for all beliefs? What about things for which there are no evidence, eg value judgements - I believe fairness is more important than freedom (or vice versa). Seems like an impossible standard to need evidence for everything.

Interesting angle. Makes me ponder: What if Oracle owned Facebook?

For learning purposes I created quic[0]. I wanted to strip it down to the bare minimum for running something in a "container". I got as far as having it use a preexisting network namespace. The networking part felt like a major piece of work (setting up the network in bash was tedious) so I figured I'd call it a day and leave it as is. Lots of fun and learned a lot about containers/namespaces in the process.

[0] https://github.com/archevel/quic

That depends on the tooling used. One way for linters and static analysers is to only run them on files touched by commits. For test coverage (if that is important) you can use something similar to detect the coverage for those relevant files. It really depends on your setup though.

What I usually aim for is that all new code/commits conforms to style and other requirements like having tests etc. Usually it is possible to configure tools to only flag something as a bad build when the new code doesn't conform to those qualities.

However, this means that as soon as you start mucking about in the legacy code, that code need to be covered by tests and formatted to pass any style checks and linters. That is not an insignificant amount of work so plan accordingly.

Also, I find it useful to remember that even if the code is not to my liking (for whatever reason) it might be consistent. I.e. maybe it uses some coding style I am unfamiliar with and I would rather it used another it is often detrimental to start changing it to be more inline with my preferences. Consistently poor code is often easier to reason about than code that is a mix of different preferences and patterns. This also goes for when thinking about introducing new technology to an existing code base (see the lava flow antipattern).

An organisation always has some kind of culture. If it is "defined" (I interpret that as something being written down) or not doesn't really matter. Whatever is defined in that sense is not really the culture of that organisation. You can define your culture in any way you want with whatever value statements you desire an organisation to embody, but most likely those will not reflect the actual culture in the org.

That's not to say that trying to be explicit with the culture you want in an organisation is bad. It is just recognising that the words are not the culture. The people, the way they interact and the atmosphere in the company and what drives it is what creates the company culture.

Have we really not understood OO at all so that we have to reinvent it all the time?

We haven't. I think the popular OO languages shows this. In both Java and .Net the focus is on classes, not on messages passed between objects. But class hierarchies are not essential for message passing. Classes are mainly a way of decomposing an application into manageable logical parts of interacting chunks. Looking at how many language features center around classes and class hierarchies (interfaces, abstract classes, generics, inheritance etc) as opposed to how many facilitates different forms of interactions between objects (you basically have method calls and arguably async/await) it seems clear to me that these languages are more "class oriented" than object oriented...

Seems like a variant on "Existential Angst". Maybe not exactly, but the sense of loss of purpose feels fairly close.

There is a brief explanation here:

http://curious.astro.cornell.edu/about-us/57-our-solar-syste...

So a true post-scarcity will never exist. People will just invent new goods or services to go after in the future when today's iphones and sportscars have become affordable. Not because they need them, but for the simple fact that they are difficult to obtain.

This assumes material wealth remain a source of status. If all things are easily aquired, then there is no reason to hold people with certain possesion in high regard. Instead knowing social codes and ability might become even more important. Perhaps the exception would be historical artifacts abd handmade things, asuming those could not be perfectly copied...

I realy fail to see how being a "feminist" government has any bearing on the issue at hand. Sure the government screwed up, but the rant part just takes away from the valid points you've raised.

Several large studies of mobility in developed countries in recent years have found the US among the lowest in mobility. One study (“Do Poor Children Become Poor Adults?") found that of nine developed countries, the United States and United Kingdom had the lowest intergenerational vertical social mobility with about half of the advantages of having a parent with a high income passed on to the next generation.

The above quote from wikipedia article on mobility in the US [1] highligts an important point. The US as the land of opportunity is clearly a false image, since you have a lower chance of climbing out of poverty there than in a lot of other countries.

[1] https://en.wikipedia.org/wiki/Socio-economic_mobility_in_the...

I have been writing one available at https://github.com/archevel/ghoul it is not finished in any way shape or form. I'm currently rewriting the evaluator to do tail call optimization in my spare time and when that's done I'll work on handling macros.

If you want a more complete one you could check out zygomys https://github.com/glycerine/zygomys

I wrote a lisp in Go a while back and got to the point where it could parse and interpret basic lisp code. I got stuck on making it do proper tail call optimization since I didn't want it to do trampolining. Since Go doesn't support TCO the only way I came up with was to rewrite the interpreter either use a big while loop or gotos instead of relying on function calls. Does Swift do TCO making this trivial? Anyone else solved implementing a lisp with TCO in an elegant way in a non-TCO language?

People don't suddenly become less obnoxious, more mature, less possessive, just because there's someone else around.

In my experience the opposite is true people DO become more mature in the presence of others. In general people tend to take a breath and try not to lose face by becoming upset in most social contexts. Also a third party can mediate conflicts, couples therapy comes to mind. Sure that's not the same thing as romantic involvment, but I can imagine conflicts deescalating just by having a third person around who can see both sides or take side or point out that the arguing parties are both behaving as idiots.

I started by watching https://www.youtube.com/watch?v=HPuvDm8IC-4 and reading https://www.infoq.com/articles/build-a-container-golang

Also "man namespaces" on a linux machine will give some deeper documentation.

I second this! I watched Liz Rice's Golang UK 2016 talk and was inspired to write something to create containers. I was also interested in x86_64 assembly so decided to go with that.

In the end it is realy simple to create something to run containers even in assembly since it is just a few syscalls to set things up. Ended up with: https://github.com/archevel/quic

The main difficulty was figuring out how to do the netns part.