Are you hoping for it to remain the same or are you hoping for an increase compared to usd? Asking because you mentioned stored. What if you could buy shares with btc? If value just sits there and is not used in a productive way - things companies try to do - you're subscribing to a very static world view. It might make sense if you are close to retirement - where people usually move to stable assets - but generally you want your assets to be used in a productive way rather than hidden away.
If it remains the same value its USD price will increase at the rate of devaluation of the dollar which is 7% on average (value halves every decade)
If I wanted to make my bitcoin "productive", I could lend it to businesses and then receive interest on top - so bitcoin would go up in price at 7% and then I'd also receive back 5 to 10% more bitcoin per year.
No other asset will ever come close to this, without taking on risk or extra work. Which is why bitcoin will very likely also go up 2000% in value over the next decade.
This is something very Japanese, they like to patent everything to the extent I think it's something cultural. My company (Japanese owned) made us sign something on the lines that the company can patent inventions of employee without his consent.
I bought some stuff from auctions houses that buy returned stuff but what you get is very random, either as new stuff or complete junk. Coupled with the fact that there is no return policy on these returned items, non transparent pricing (they sometimes charge VAT and various taxes) and shipping is overpriced it's best to stay away unless you can go in person and check the items before you bid.
In any case the return ratio is priced in and we're very likely paying higher prices for new items to account for these returns.
> Be careful not to practice your righteousness in front of others to be seen by them. If you do, you will have no reward from your Father in heaven.
> So when you give to the needy, do not announce it with trumpets, as the hypocrites do in the synagogues and on the streets, to be honored by others. Truly I tell you, they have received their reward in full.
> But when you give to the needy, do not let your left hand know what your right hand is doing
> so that your giving may be in secret. Then your Father, who sees what is done in secret, will reward you.
I agree with this, it all depends on your motivations of your acts. If you give to be seen you're just seeking attention but of course for the receiver it's not less valuable.
It seems he gives some money to make more money (views), is that something altruistic? I don't think so.
Can understand why some primitive people were not big fans of gay people, they would not 'multiply' the tribe. I wouldn't describe it as arbitrary, after all it was compiled by 'learned' scribes but more like based upon the needs of those times.
the problem is that he isn't doing it to show of his generosity, but that doing what he does is the way he gets the money in the first place. he is not independently wealthy and bragging about how he spends his money, but he figured out how he can earn money that allows him to give it to others.
so denying him publicity would deny him the very means to do good in the first place.
he gives some money to make more money
or he makes money in order to give money. in the end, what matters is how much money he keeps for himself and how much he gives away. it looks to me he is giving much more than he is keeping.
As a software dev who is confident with coding I would not use this because I don't want to lock myself to a platform (vendor lock-in).
Someone who is a rookie might use it but it seems that it requires more than basic knowleadge (e.g. REST, SQL, auth, etc).
I started playing around with it and came to the conclusion that it needs a bit more development before it’s ready for me.
My use case: I’ve been meaning to build a simple backend for a chatbot that’s active in a community I frequent. The functions I want to add to the chatbot are just for fun, and my time on this is 100% voluntary. All I need is a backend to handle two types of requests, one which inserts a record into a persistent data store, and one which retrieves the count of records associated to the requesting user + the date of the first and the most recent records.
There’s nothing there that I don’t know how to code and deploy. But even the time it would cost me to compare prices of the various services which offer backend hosting is more than my little use case is worth. Then I still have to figure out the deployment path for my code, and stamp out the code itself.
The 1000 requests per month + 50k db records you get for free from this service would have been more than enough for what I’m doing. But unfortunately the functionality that I need isn’t quite there yet.
If you're looking for a similar solution that has 0 vendor lock in, checkout https://www.flyde.dev. It's still WIP but Open-Source and comes with a VSCode extension. I'm planning on launching it soon as well :)
Google is just the middle man here, creators can turn off ads on videos if they want to but a lot of them need revenue or at least want revenue so the question becomes what's the best way to reward creators for their work? There are multiple models that I can think of but there will be much less people on yt if it would cost even a few cents. Once you're used to free stuff, even with bloated content as now it takes a while to get used to paying. The current model works because 3rd parties pay and not the actual consumer.
I'm curious how does yt share profit with creators for views from paying subscribers.
London has a number of red telephone kiosks turned into libraries. I belive they are administered by local groups which move the stock around once in a while but I would suspect it's difficult to manage this online since there is no check-in/check-out process.
It sounds like the Street Library project here in Australia. Every little suburb and village now has multiple little enclosures that basically encourage to people to put in a book they have finished reading and take if they want. All grass roots driven and seems to work well with very little abuse.https://streetlibrary.org.au/
My wife has constructed, and contributed to, a few of these. I see them around town, even in residential areas; and, as you say, there is almost no vandalism or abuse.
LittleFreeLibrary.org applied for trademark control of “wooden boxes with a storage area for books”. Additionally, LittleFreeLibrary.org now stakes claim to word variations beyond their trademarked name “Little Free Library”, such as “little library” and “little libraries”.
From a beautiful idea in 2009 to these terrible ideas now. :-(
Excuse my ignorance but what are the advantages of using such a system over the standard build systems of various languages (vite, gradle, maven, pip, etc)?
In my experience there are two main advantages: reproducibility and cross-language support.
Build systems like maven can read from the entire filesystem (e.g. it reads from ./~m2) and you might end up with artifacts that depend on the state of the machine. This makes debugging production issues harder. You can of course be careful with other build systems to stay reproducible but it's easy to make mistakes and buck will enforce that you don't.
Companies like Meta and Google have huge monorepos and are using multiple languages. It's common for developers to deal with multiple languages and for projects to depend on other languages. Buck can deal with that very naturally and avoids the engineers to deal with multiple build tools.
There are other upsides and downsides listed on their website.
If you only use one language, and that language has a reliable, reproducible build system that gives you the guarantees and functionality that you require, then not much.
Here’s how I used Bazel (and how I now use Nix).
I am provided a configuration file that specifies what a given instance of my program must do. I use language A that can natively understand this configuration to code-generate a file in language B (which is significantly more suited to the performance requirements of the program)
This file is then built along with generic program code. It is used to process a lot of data.
As an interface to this program, I have a HTTP interface that can communicate with it. It needs to understand the kinds of outputs the program will produce, so some of this HTTP interface is also code generated in language A. The interface is interactive so typescript is generated and then compiled too.
In order to process the output from the program, I need to produce extensions for languages that users of the output use: Python and R. These need to understand the kinds of data being used, so are also code generated - then built. They’re then tested against requirements defined by the config (so the tests are also code generated).
Each of these stages have dependencies required when building and dependencies required when running, and there are several languages involved.
I also need to be able to express the entire process as a function, because it’s something that needs to be run very frequently on different configs - sometimes in collections of configs that need everything built at once. It needs to be build on several different machines, sometimes desktops and sometimes remote servers, sometimes on clients’ hardware (depending on the needs). I need confidence that something that works on my development machine will work, in entirety, on a completely different machine with minimal prior setup. And I need it to be easy to do, easy to maintain, and I don’t want to mess around with many different build systems that have entirely different use cases, entirely different ideas of how build/runtime environments should be handled, entirely different languages to configure them - and many of them are rigid and don’t have a concept of functions, they’re just “state your dependencies, kthxbye”.
All of the above is absolutely trivial with bazel if you know where to tread lightly (e.g. surrounding Python environments). It’s also very easy with Nix once you get used to it, and you don’t need to tread lightly there - it has stronger guarantees.
That's very interesting, I've never exposed to such a development environment. Is there maybe a GH repository or something that I can see the above in action? Thank you
how would you compare (both in terms of what relevant difference it makes from a usage perspective and of a qualitative evaluation of what's better/worse) Bazel's Starlark with Nix's own functional DSL, for the purpose as a language for build file definitions?
In Nix, the sequence of events that lead to your build are figured out on the language level. A build is this sequence of events.
In Starlark, you have to do things in a specific order - and that can get messy. It has a bunch of built-in phases that mean WORKSPACE, .bzl and BUILD files all have different levels of ability. A workspace can define a dependency (e.g. a http_archive), load a file into bazel, then call a bazel function from it. If you want to do that outside of a huge unmaintainable file, you have to break the steps down into multiple bzl files - one that does the download, then another that loads the dependency and calls it. And then you can call the latter from your workspace. BUILD files can do neither of the above and can only really define builds. So you end up with awkward file arrangements to load the right dependencies.
In Nix, anything you evaluate is a Nix variable. A function is a variable, a derivation (target) is a variable. You can refer to it natively and do what you want with it.
In Bazel, everything is referred to in a global register via labels, which are just strings. If you want two versions of the same thing that are the result of a function call, you have to give them different labels, so you can end up screwing around with string manipulation to generate unique identifiers.
This also feeds into a deeper issue. Bazel loves its global registry. Names from your dependencies are also your dependencies - so if the author of a project decides it hates the users and wants to enforce a “com_github_owner_repository” as its workspace name (because who doesn’t love Java-style conventions), you’re stuck using “@com_github_owner_repository//:library” throughout your codebase, anywhere you rely on that dependency. And to load in that dependency’s own dependency, you have to either load a special file and run special functions that the author provides, or you have to copy a bunch of code into your WORKSPACE file, making sure you give things the naming conventions used within the dependency.
In Nix, you name things whatever you want. If something you depend on has dependencies, it manages them itself - you can override them if you want.
Bazel doesn’t have much of a registry of third party repos. The onus is on you to scour the web, find an archive you want, grab the hash, and sometimes write your own build file to explain how it gets put together.
Nix has a truly vast repository of dependencies, which can be library dependencies or programs (in the latter, it’s the largest repository of applications out there - bigger than even debian and arch provide).
Bazel is maintained by Google, and maintainers make it very clear that they are spread thinly and don’t enjoy doing it. Some projects are completely stalled due to lack of maintenance. When bugs are found in the internals, they don’t get fixed for a long time. It’s based on Blaze, just like VSCode is based on Visual Studio, and there’s a feeling that it is being held back when things that could benefit users would be incompatible with their own system. There’s always the looming apprehension that Google are going to abandon it as soon as the next shiny thing comes along, or as soon as the people who work on it get promoted. Want to submit a PR? Sign this agreement first, then we might look at your PR, then we might merge it, might say no, but (note: speculation) an eerily familiar yet unattributed push might arrive a few months later from a googler.
Nix is full FOSS, with the standard open process you’d expect.
In favour of Bazel.
In Bazel, because you’re expected to follow a certain flow, errors are friendlier and easier to figure out. Bazel knows what you’re supposed to be doing and can help. When it builds things and fails, the intermediate files are saved in an easy-to-find place within your local directory (as a symlink) so it’s easy to explore and figure out the issue.
In nix, a derivation (target) truly resolves down to the tiny operations that put it together. It doesn’t know what you’re trying to do with it, so a typo at the topmost definition of a derivation can end up giving you horrific errors about low level list operations. If an error occurs in the code you’re building, intermediates can be found by copying a huge nix store path from the terminal and navigating to it, but it is a laborious process.
Starlark is based on Python, and it’s familiar to a lot of people. The overhead of learning the language is just a case of “oh it’s Python but without X, Y, Z, and… without fstrings!?”.
Nix is an entire language, with its own conventions, its own library, and its own syntax. It’s easy enough to learn if you’re used to picking up new languages (and honestly is one of my favourite languages now), but that’s an overhead. Most people think imperatively and eagerly, and nix is functional and lazy, so it can be hard to figure out how to accomplish something.
Bazel has an actual build system. It has native support for a bunch of languages. Nix is very much DIY - if you’re using make or CMake then the mkDerivation can do a lot of things for you, but for a developer using the two technologies together is unpleasant. We went as far as making our own build system in Nix that invoked e.g. gcc directly rather than try to work with cmake.
