• 19 Posts
  • 234 Comments
Joined 1 year ago
cake
Cake day: June 15th, 2023

help-circle

  • pcloud

    I’m not much of a Cloud Drive user, but experimented with pcloud. It has a CLI tool and the ability to show up in the local filesystem, so you can browse through with your graphical filemanager: https://www.pcloud.com/download-free-online-cloud-file-storage.html

    Free Tier

    I only used the Free Tier without time limitation. Just logged in to the web client in browser to see if my files are still there, and I still have my files uploaded 2 years ago. I think Free Tier starts with 1 GB of free space and you can unlock more and more if you do some tasks like installing the CLI tool and such (I have 5 GB of space without time limtations). And the files are stored in European servers; not sure if I had a choice at account creation time or if this is tied to the location where I am.

    If you want more space, you can either pay annually or a one time payment for lifetime access (500gb for 200 Euros, 2 TB for 400 Euros…).



  • So yeah, exception as part of explicit function signature is a vast improvement, I completely agree

    Hmm, I’m not sure if you are being sarcastic. In my reply I didn’t meant encoding Exceptions into Type system. Is this a type and you probably meant “Error Types as part of” instead “exception as part of”?

    Honestly I don’t know how Exceptions as part of type system would even look like. Because each function call in a chain would need to have all information from previous function call, otherwise that information gets lost to the next caller. The problem is the hierarchy of function and method calls. Somewhere some objects and functions can be edited to Throw a new Exception, that is not handled through the entire chain. And for the higher function caller, there is 0% way of knowing that (through code, besides documentation off course).


  • Read my reply with a handful of sea salt. I just read tutorials and documentation a bit and did Hello World.

    Zig is pretty cool too! It can run C code directly just like C++ does (I think), kind of drop in replacement. From my reading so far, Error Handling is kind of a marriage between Go’s and Rust’s Error handling. Actually pretty cool. It has Error Types, but is kept relatively simple and doesn’t force to do all the stuff. It has Try and Catch keywords to handle errors elegantly, but don’t be fooled, this has nothing to do with Try…Catch blocks for Exceptions. Zigs Try and Catch are more like Rusts Result type handling, at least from what I read so far.

    I lean more towards Zig than Go, but it still has not reached stable 1.0 release.


  • My anecdotal experience is that Rust code, for example, has more calls to unwrap than I’d like. The problem here is that simply unwrapping results will crash the program on errors that could have been a user-visible error message with exceptions.

    unwrap() is explicitly not handling the error in a Result type. If you must do this, then at least use except(), to unwrap the code but with an error message if program crashes. Its the equivalent of having Exceptions and then not handling that exception. Therefore your critique is not valid here.

    One problem with Exceptions is, you never know what code your function or library calls that can produce an exception. It’s not encoded in the type system or signature of the function. So you need to pray and try catch all possible exceptions (I look at this from Pythons perspective), if you don’t want a Catch…All, which then you wouldn’t know what error this actually is. And you still don’t know where this error came from or happened in the code, how deep in the function call chain? Instead Errors as Values means its encoded in type system and you can directly see what errors the function can cause and (in Rusts case) you must handle the error, otherwise program won’t compile. You don’t need to handle anything else in this context. Compiler ensures that all possible errors are handled (again within context of our discussion). Vast improvement!





  • AI is fed by human input. If humans start and use AI more and more, and less human generated content, then soon AI will be fed by AI content. With each step of the feeding stage will amplify hallucinations and problems. Which will not help in the slightest with fake news and information, as fact checking could potentially be a source of fakes too. Only corporations have the money and resources to create the biggest LLMs, which means they will be the entities controlling everything.

    We don’t know if AI will grow exponentially forever. There are lot of downsides and its likely that countries in the world will ban AI. AI is already transformative technology, as we have seen. Partly because the world was not ready for how fast they improved and because no legislation exist. The question is, if AI is a bubble for short time and how long it will last. Maybe the next big AI improvements are done with Quantum Computers in a few decades from now. Who knows.


  • I don’t like it either, but I’m not entirely sure why. Maybe the biggest flaw to me is it uses Python style indentation for structuring as part of data logic. It doesn’t feel like a configuration language to me and it does not feel simple too. It’s also unlike most programming language structures (maybe besides Python), so it looks weird to read and write. Other than that, I don’t know exactly why I don’t like this format much. Admittedly, I did not do much in YAML, so because lack of experience take my opinion with a thick grain of salt.

    We have JSON and TOML. I quiet like TOML. We have “better” alternatives, that are probably easier to parse. And therefore there is not much need for YAML. Maybe if YAML was the default config format for Python it would get off the ground and be accepted more often.










  • Sounds a bit like a repogrammable ROM (which is no longer ROM in that case, ROM=Read Only Memory). Kinda what FPGA does, if I’m not mistaken (and what you were referring to, right?).

    If you take a look at the die you’ll find what is in effect a ROM on board, a look-up table defining what each instruction does. A machine with said capability can change this ROM, and not merely emulate a different instruction set, but be that instruction set.