1. 11

    This raises an interesting point and one that I think browsers could address. Much like they carefully craft information display to help people recognize being on genuine/secure sites, one can imagine a browser feature where if the link text contains a link and that link doesn’t match the href, a warning is displayed.

    1. 3

      It’s honestly somewhat shocking that with the amount of thought that goes into other browser security features, this one was overlooked. This also feels particularly dangerous in HTML email.

      1. 1

        I like the idea. I’m somewhat concerned about false positives with URLs that don’t match but redirect or even with typos. So the warning has to take that into account and shouldn’t be too scary. Or you need to perform a request to detect redirects or implement a heuristic etc, but all that is prone to mistakes.

        This is likely more fun on mobile which doesn’t have a mouseover (do people still check that?)

        1. 1

          Facebook’s tracking links would break. Probably a good thing, but I’m not sure everyone will agree.

          1. 1

            It could be presented in a way that just makes that more obvious and gives the user the choice to follow the displayed link or the href. Then users could chose to be tracked or not. Definitely with you that it’s a good thing and that not everyone will think that—clearly the people who make trackers think they’re okay at least.

            1. 1

              Same with the links in google search results, twitter (t.co), slack, …

          1. 6

            Zig article -> 44 upvotes, Scala 3 -> 14 upvotes.

            I am not sure what Scala is used for anymore. F# / Rust / Kotlin and probably OCaml ate away much of the user base over time. If you are an ex Scala coder, what language did you switch to?

            1. 11

              There’s 18 Apache projects written in Scala

              • Apache CarbonData
              • Apache Clerezza
              • Apache Crunch (in the Attic)
              • Apache cTAKES
              • Apache Daffodil
              • Apache ESME (in the Attic)
              • Apache Flink
              • Apache Hudi
              • Apache Kafka
              • Apache Polygene (in the Attic)
              • Apache PredictionIO (in the Attic)
              • Apache Samza
              • Apache ServiceMix
              • Apache Spark
              • Apache Zeppelin

              There’s some big names there (Spark, Kafka, Flink, Samza), especially in data movement. Also Netflix has atlas (time-series DB), Microsoft has hyperspace. Seems like most Scala code is associated to Spark in one way or another.

              1. 2

                Huh, I thought Kafka, Flink and Samza were written in Java. Shows what I know. Neat link!

                1. 2

                  This overstates the case for Scala a bit. Check the founding years of these projects. Kafka and Spark, which are two of the most popular projects in this list, were created in 2011 and 2014, at the height of Scala popularity. Both projects were written in Scala, but had to put significant effort into engineering a first-class pure Java API. Kafka team even rewrote the clients in Java eventually. GitHub repo analysis has the Kafka codebase as 70% Java and 23% Scala.

                  It’s true that Spark does use Scala a bit more. GitHub there has Scala as 70% of codebase, with Python 13% and Java 8%. But Spark might just be the “perfect” use case for a language like Scala, being as focused as it is on concurrency, immutability, parallel computing, higher-order programming, etc.

                  I also closely tracked development of Apache Storm (created 2011), and it started as a Clojure project, but was eventually rewritten (from scratch) in Java. There are lots of issues with infrastructure software not sticking with vanilla Java (or other “systems” languages like C, Go, etc.). Apache Cassandra and Elasticsearch stuck with pure Java, and had fewer such issues. Durability, simplicity, and ecosystem matter more than programming language features.

              2. 8

                It’s still pretty big in data engineering. Apache Spark was written in Scala.

                1. 6

                  The company I work for uses Scala for data engineering. I don’t think that team has any plans to move away from it. I suspect that the use of Scala is a product of the time: the company is about ten years old; Scala was chosen very early on. It was popular back then.

                2. 7

                  Elixir and loving it for almost 6 years now. I miss a couple of Scala’s features; in particular, implicits were nice for things like DI, execution contexts, etc. I don’t miss all the syntax and I certainly don’t miss all the Haskell that creeps in in a team setting.

                  1. 6

                    If you are an ex Scala coder, what language did you switch to?

                    Python, now Go. At one point I figured I could ship entire features while waiting for my mid-sized Scala project to compile.

                    I hope they addressed that problem.

                    1. 3

                      YAML in mid 2015 (I took a detour in infrastructure) but Clojure since 2019 now that I’m a dev again.

                      FWIW I liked Scala as a “better Java” when I started using it around mid 2012, until early 2015 when I left that gig.

                      I remember that I found it very difficult to navigate Scala’s matrix-style documentation; and that I hated implicits, and the operator precedence. I loved case classes, and I think I liked object classes (not sure that’s the right terminology). And I liked that vals were immutable.

                      Compile times didn’t bother me that much, perhaps because I worked on early-stage greenfield projects with one or two other devs. (So didn’t have lots of code.)

                      I liked programming with actors (we used Akka) but we found it difficult to monitor our services. Some devs were concerned about loss of type safety when using Akka actors.

                      1. 2

                        Akka actors are type-safe now for several years now.

                        1. 2

                          Off topic: there’s a lot of conversation/blog posts to be had about devs finding themselves in infrastructure. I’m there at the moment, and it’s a very different world.

                        2. 3

                          I’m using Scala for my hobby projects. It does all I need. I like multiple argument lists and ability to convert last argument to a block. Implicits are cool, though they need to be controlled, because sometimes they’re confusing; for example, I don’t really understand how uPickle library works inside, even though I know how to use it. Compilation times are not that bad as some people say; maybe they were bad in some early Scala versions, but they’re not as bad as e.g. C++. It works with Java libraries (though sometimes it’s awkward to use Java-style libs in Scala, but it’s the same story as using C from C++ – it’s a matter of creating some wrappers here and there).

                          1. 3

                            I wrote several big scala projects a decade ago (naggati, scrooge, kestrel) but stopped pretty much as soon as I stopped being paid to. Now I always reach for typescript, rust, or python for a new project. Of the three, rust seems the most obviously directly influenced by (the good parts of) scala, and would probably be the most natural migration.

                            Others covered some of the biggest pain points, like incredibly long compile times and odd syntax. I’ll add:

                            Java interoperability hurt. They couldn’t get rid of null, so you often needed to watch out and check for null, even if you were using Option. Same for all other java warts, like boxes and type erasure.

                            They never said “no” to features. Even by 2011 the language was far too big to keep in your head, and different coders would write using different subsets, so it was often hard to understand other people’s code. (C++ has a similar problem.) Operator overloading, combined with the ability to make up operators from nothing (like <+-+>) meant that some libraries would encourage code that was literally unreadable. Implicits were useful to an extent, but required constant vigilance or you would be squinting at code at 3am going “where the heck did this function get imported from?”

                            1. 2

                              2 days later, Scala 3 -> 44 upvotes ;)

                              1. 1

                                I’m currently in Scala hiatus after nearly eight years as my primary stack with a splash of Rust, Ruby, Groovy, and a whole lot of shell scripting across several products at three companies. This included an IBM product that peaked near $100M/yr in sales. The major component I managed was JVM-only and 3/4 of it was Scala.

                                For the last few months, I’m working in Python doing some PySpark and some Tensorflow and PyTorch computer vision stuff. While I concede that the Python ecosystem has certainly matured in the 15 years since I did anything material with it, my preference would be to rewrite everything I’m writing presently in Scala if the key libraries were available and their (re)implementations were mature.

                              1. 4

                                Alternative perspective:

                                Lenovo and the new Linux desktop experience

                                I wrote this about the X220 and X1C4. But I have had an X1C7 for 2 years, and X1C8 as my soon to upgrade. Same comments mostly stand!

                                1. 4

                                  Also want to put in a plug for the Trackpoint II keyboard. Probably the only laptop where you can get a replica of the keyboard for desktop ergonomics. Combine with an 3M LX550 laptop stand and any wireless mouse, and you can quickly convert the laptop into an ergonomic desktop with eye-height monitor and webcam.

                                  Keyboard: https://www.lenovo.com/us/en/accessories-and-monitors/keyboards-and-mice/keyboards/KBD-BO-TrackPoint-KBD-US-English/p/4Y40X49493

                                  3M stand: https://amzn.to/3fzHCwb

                                1. 3

                                  So is this sort of like glib in scope and value proposition, but without the GNOME history?

                                  1. 5

                                    GNU ddrescue has a really nice progress tracker, and is built for high copy speed. I use it to clone drives all the time from an Ubuntu USB stick. If you are using USB3.1+ and an SSD, you can clone drives at 400-500MiB/sec, which is quite something. But, like dd, it’ll work for any file or file-like device. Here is what the progress tracking output looks like.

                                    1. 8

                                      It looks like wcp here can handle directories, which ddrescue can’t.

                                      1. 1

                                        It’s either this or send the link to my girlfriend in google hangouts.

                                      1. 2

                                        Element.io mobile/desktop apps and EMS for self-hosting (utilizing Matrix.org under hood) provide a compelling open source and self-hosted alternative, IMO. Still some rough edges to work out, but a good start. Unfortunately it requires one person shelling out some time or cash for a homeserver on behalf of one’s friends, or relying on the shared services that are floating out there.

                                        (Only for programmers, though. For “normies” I’d still recommend Signal or WhatsApp.)

                                        1. 2

                                          Oh this is fun. I had written one of these for a web development course I once taught. I put CodeMirror on the top, and I integrated emmet with it for HTML abbreviation expansion. I always wanted to open source it, but never got around to it.

                                          1. 3

                                            Love this underrated book. I reviewed it and a few others in the genre of “debugging dysfunctional product cultures” in this subsection of my software management reading list:


                                            1. 11

                                              Good command, but I think I prefer it sorting in reverse chronological order, like git log. To make this change, simply prepend “-” to the --sort key. Added with that small modification to my bag of $HOME tricks here.

                                              1. 1

                                                Interesting write-up.

                                                My personal view:

                                                • Missing a mention is Parquet, IMO. Which you could think of as “columnar JSON, but fancier”. Matters when you are storing billions of rows with common columns. But, IMO, Parquet should never be the source of truth. It’s just not stable enough, nor well-supported across every platform.
                                                • The source of truth should be JSON – likely, compressed JSON, often “JSONLines” batches, using either gzip for max compat, or zstd with a custom learned dictionary for max compression.
                                                • When you are encoding JSON over the wire and are worried about fat network payloads or deserialization CPU time, I think you simply one-for-one swap JSON in memory for msgpack on the wire. Yes, I guess CBOR is OK, too, since it seems like they are roughly the same thing.
                                                1. 9

                                                  I’m a long-time Linux laptop user. I recently bought a Lenovo X1C 7th Gen, which is the generation from last year, one generation older than the X1C models discussed in the Fedora article. The two laptops are largely the same as the 8th Gen only had some small tweaks. They are both light & thin Intel architecture notebooks, with an under-powered but power-efficient Intel GPU, Intel i5 or i7 CPUs (mine is a 4-core i5), Thunderbolt 3 & USB-C charging and connectivity, and options for 1080p or 4k screens, in the case of 1080p there is a matte option with high brightness, perfect for outdoor usage. (That was what I opted for.) The 8th Gen’s main upgrade is Wifi 6 (802.11ax) support.

                                                  With the 7th Gen, I was upgrading from a ~4-year-old X1C 4th Gen, which I described in this blog post after I set it up exactly 3 years ago: “Lenovo and the new Linux desktop experience”.

                                                  Here’s my experience report on Ubuntu 20.04.1 LTS.

                                                  • Despite Lenovo firmware updates that claim to fix the issue, there is still a small issue with how this laptop handles CPU throttling in response to thermal sensors. I noticed that the issues with the throttling algorithm happen regardless of whether it’s Windows 10 or Linux, but they are worse under Linux. (I monitor the CPU frequency closely using the cpufreq gnome-shell extension, and also with the i7z command-line tool.) Here’s the good news: someone has developed a systemd service you can install called “lenovo_fix”, part of a github repo called throttled, that simply fixes this issue. Now I can run my 4 cores at 4.0 Ghz when on AC, and 2.6 Ghz when on battery, and throttle down to 2.0 Ghz only when the system is under extreme load and overheating. But, without this lenovo_fix tool installed, you’ll see the CPU throttling down to 2.0 Ghz under pretty much any load whatsoever, whether on AC or battery. Here’s the link to install that.

                                                  • On my X1C 4th Gen, I used the laptop with the OneLink+ dock. This used a proprietary Lenovo connector that seemed to have full support for gigabit ethernet, power, and USB 3 through a single connector. This included Displayport output running a 4k monitor at 60 Hz. Linux had no problem working with this dock and I used it for 3 years without issue with my 4th gen, despite the odd proprietary OneLink+ connector. For this new laptop, I decided the right dock for me was the Lenovo Thunderbolt 3, Gen 2 Dock. This is the only dock that supports 4k @ 60 Hz over Displayport, while also having a number of USB ports. On the specs alone, it would seem to be an upgrade from my OneLink+ dock: Thunderbolt 3 via USB-C rather than only supporting USB 3 over USB-A; support for even more display options; a mix of USB-A and USB-C ports; and the simplicity of a standard Thunderbolt 3 all-in-one cable for charging and all connectivity. I have been using this dock under Linux for about 2 weeks now, after upgrading its firmware as Lenovo suggested upon purchase. To my chagrin, there is also a small issue with this dock – every once in awhile, it seems the xhci_hcd usb hub built into the dock “crashes” and forces me to either re-dock or unplug/replug USB devices (which, annoyingly, include my mouse and keyboard). It’s pretty rare though – it happened twice in 2 weeks. In dmesg, there’d be a kernel trace about it. Next time it happens, I’m probably going to try re-docking via software (via boltctl, perhaps) to see if that works well as an automated recovery; if so, I can install some sort of fix for that.

                                                  • Finally, there is one issue that doesn’t bother me but which will probably bother other people. The alsa and pulseaudio configuration for this laptop leads to Linux only using 2 of the 4.1 channels that are available in the Dolby speaker system. This is discussed extensively in a thread of frustrated users on GitHub, and after a multi-month effort of debugging, has resulted in one user successfully getting Linux kernel patches upstream to fix the issue in kernel versions 5.8 and 5.9. Unfortunately, though, those kernel versions are not in Ubuntu 20.04.1 LTS, so it won’t be fixed in Ubuntu for awhile. For my own usage, this doesn’t matter as I’m always using either my own USB speaker system or a Bluetooth headset.

                                                  • Everything else about the laptop works flawlessly and out-of-the-box, so much so that I simply cloned my drive from my 4th Gen over to a couple partitions on the 7th Gen, and got back to work.

                                                  I’m happy with this laptop as an upgrade over the 4th Gen, from the standpoint of the fast CPU, the two extra cores, and more memory. It also has a slightly sturdier build, especially around the monitor, which was a little too thin and flimsy in the 4th Gen.

                                                  I am not sure if all of the above issues afflict the 8th Gen. I’d be curious to hear if folks have a different Ubuntu experience with that build. I think the Fedora certification of the 8th Gen is a good step in the right direction to get Lenovo’s X1C laptops “blessed fully” in the Linux community as these sorts of edge issues are very annoying, but Lenovo remains one of the few options for business-class Linux users who want a good mobile and desktop unified Linux experience.

                                                  1. 3

                                                    I have the same thinkpad. It runs NixOS, and here’s my (work in progress) report.

                                                  1. 3

                                                    I think the metaphor only works in a facile way. That is, when you design and implement code, you can get it working fast, or you can get it working slow, but perhaps with a more robust set of internals (internal design, naming, decoupling, testing). If you choose to ship without the robust set of internals, you have done the equivalent of using a credit card to buy a big TV, rather than paying in cash savings. You can have the TV now (the user/customer can have your software now) but you still have to pay off the TV later (you’ll have to spend some time doing some refactoring work which might delay a future project). Spending debt in this way can be a good thing when your expectation is that the value of the user/customer having the software today is high, and the ability for you to “repay the debt” later is also high. It can be a bad trade when a software business decides to “put every purchase on its credit card” and to “never pay back any past purchase”.

                                                    I find that engineers sometimes use the metaphor this way, and in that case, it can be healthy. But I find a lot of engineers, perhaps the majority, use “technical debt” to refer to “any project the user can’t see”, so it captures a very wide range of projects – framework rewrites, devops infrastructure, backend schema changes, and so forth. When used this way, it just seems like a blanket justification for “internal non-customer-facing projects”, and thus loses its value and meaning as a term.

                                                    1. 2

                                                      This is a good post. I wrote “JavaScript: The Modern Parts” for a historical take on the JS ecosystem and where the modern toolchains like webpack and babel fit in. The two recommendations I had as a follow-up to that post is the OP here, as well as a 20-minute YouTube talk on how to effectively use npm run-script.

                                                      1. 7

                                                        Design Patterns is better understood if you understand that in the 80s and 90s (which I didn’t experience as the metaphorical dark ages the author invokes), people expected and hoped that the software industry would become dominated by OEMs making components in object oriented languages; pretty much what the automotive and electronics industry are like now.

                                                        In a world like that, it pays to have a very versatile and popular component. So before you ship yours, you have to think long and hard about the ways people may want to use and extend it. That’s what makes Design Patterns worth reading, the way the authors think extensively about design decisions, and how they may hinder or facilitate further use.

                                                        They used the metaphor of Christopher Alexander’s Pattern Language; programmers building a nice neighborhood for each other, employing patterns to consider each others’ wishes and needs. It’s a very social and romantic view of software development.

                                                        The actual way the Computer industry solved the problem of duplication of effort was with open source. Not only is there an infinite variety of ‘components’ to choose from, the components themselves can be modified at will. Writers of a component don’t have to anticipate every possible use case, as the users will write a patch if necessary.

                                                        1. 2

                                                          Very well said. The design principles discussed in the book are probably better applied to designing public and hard-to-change APIs (like HTTP/REST APIs), rather than “all modular code”. Modularity is usually better achieved with simple functions, rather than classes and type hierarchies – that’s a lesson that would become strikingly clear in the era of open source Python. I discuss this in my Python style guide here.

                                                          To illustrate: the requests module is a great example of modular re-use because it hides most of the gnarly details of making HTTP requests behind a simple function: requests.get(...). Rather than exposing a deep class hierarchy modeling HTTP (as is common in Java HTTP libraries), and a wide set of methods or interfaces that you need to couple your code to. You just call the function, get a simple return value, and you’re done. Low coupling, low mental overhead, high re-use.

                                                          The book “The Philosophy of Software Design” comes up with a great name for this distinction: “deep vs shallow classes/modules”. You can see the reference visually in this tweet.

                                                          1. 1

                                                            Yes, and the stereotypical discussion about Design Patterns was one between Java engineers designing an internal API that could be changed on a whim. YAGNI

                                                            A Philosophy of Software Design sounds interesting. I’ll check it out.

                                                        1. 4

                                                          Design Patterns is an interesting read but it is also heavily grounded in vulgar OOP.

                                                          What is a good collection of design patterns for functional languages? Types? Declarative languages?

                                                          1. 2

                                                            I’ve gotten some value from Enterprise Integration Patterns because it describes patterns that arise among programs rather than within them.

                                                            In practice, we often need to exchange data with a system owned by another team. We don’t have control over the technology they’ve chosen, but patterns like “content-based routing,” “request reply,” and “envelope wrapper” are still pervasive in distributed systems, no matter the programming language.

                                                            1. 1

                                                              Peter Norvig’s Design Patterns in Dynamic Programming is a great antidote to the GoF book.

                                                              1. 1

                                                                It’s very Python-specific, but “Fluent Python” does a nice job mixing a discussion of language features, style, idioms, and patterns in a unified way.

                                                                For functional languages, the closest I’ve come across is probably “Elements of Clojure”. But I think it’s a little more abstract than you’re suggesting, focused more on abstract design areas rather than concrete patterns.

                                                                For Java and more traditional OOP/imperative languages, “A Philosophy of Software Design” is a nice read in this category. It’s also a bit more abstract than “Design Patterns”, but I think also has a better shot at a density of timeless insights as a result.

                                                              1. 10

                                                                This is a really nice post. (It’s a reflection on the book “Design Patterns”, by the “Gang of Four”.)

                                                                The complaints that the book is “outdated” (it was published in 1994) strike me as similar to complaints that “The Pragmatic Programmer” is outdated (hardly discusses F/OSS, predates the ubiquitous web) or that “The Mythical Man-Month” is outdated (uses examples from mainframe era, has some gauche language choices).

                                                                Pretty much any book about “modern” software programming “techniques” is “outdated” within 10 years of publication, and especially so if it was published in the 70s, 80s, 90s, or early 00s. I believe you have to read these books in their time and place, and draw out the timeless lessons while recognizing and chucking the junk that doesn’t hold up to the passage of time, and to the new industry state-of-the-art.

                                                                “The Pragmatic Programmer” recently got a 20th anniversary 2nd edition update/revision, a rarity in the world of classic texts in programming. Here was a quote from the preface, which can also be found freely online:

                                                                Back in the 1990s, we worked with companies whose projects were having problems. We found ourselves saying the same things to each: maybe you should test that before you ship it; why does the code only build on Mary’s machine? Why didn’t anyone ask the users?

                                                                To save time with new clients, we started jotting down notes. And those notes became The Pragmatic Programmer. To our surprise the book seemed to strike a chord, and it has continued to be popular these last 20 years.

                                                                But 20 years is many lifetimes in terms of software. Take a developer from 1999 and drop them into a team today, and they’d struggle in this strange new world. But the world of the 1990s is equally foreign to today’s developer.

                                                                The book’s references to things such as CORBA, CASE tools, and indexed loops were at best quaint and more likely confusing. At the same time, 20 years has had no impact whatsoever on common sense. Technology may have changed, but people haven’t. Practices and approaches that were a good idea then remain a good idea now. Those aspects of the book aged well.

                                                                So when it came time to create this 20th Anniversary Edition, we had to make a decision. We could go through and update the technologies we reference and call it a day. Or we could reexamine the assumptions behind the practices we recommended in the light of an additional two decades worth of experience.

                                                                In the end, we did both.

                                                                As for “Design Patterns”, I always read this book as an exploration of object oriented programming design, at a time when there was, for better or worse, only a single mainstream “truly OO” language, namely, C++. (Yes, there was also Smalltalk and CLOS, and perhaps others, but hardly mainstream.)

                                                                The book then had a huge influence on Java programmers, and Java was the first time you saw dynamism (e.g. classloaders, reflection, garbage collection) and OOP mixed into the mainstream of programming, as well. It’s true that as time went on, certain languages incorporated “design patterns” right into the language. For example, Python has Iterator, Interpreter, Facade, Visitor, and Decorator built-in, and probably a few others.

                                                                The book had a big influence on me in the 00s, because it just got me thinking about programming abstractions independent of data structures. What you might call “the ergonomics of code”. So I am still thankful to the book and vocabulary it introduced.

                                                                I think it’s far too easy to take programming books of a prior era and discount their value altogether just because the tech fashions have changed. It’s a pity – there is a lot of wisdom that knows no age, even in our field of neophiliacs.

                                                                1. 2

                                                                  I think it’s far too easy to take programming books of a prior era and discount their value altogether just because the tech fashions have changed. It’s a pity – there is a lot of wisdom that knows no age, even in our field of neophiliacs.

                                                                  I am, to this day, grateful to a professor in the mid 90s who handed me a copy of Brooks (Mythical Man Month) and encouraged me to read it one day when I visited his office hours. Our conversations after I read it and asked (in puzzlement, not as a challenge) how it could still be relevant inspired me to reserve judgement. Observations during my first big project at my first big corporate job convinced me firmly that what you say is correct.

                                                                  1. 3

                                                                    Brooks is “special” because the stuff he writes about are basically how to organize a business - but with software! In his time, the art of planning how to make widgets was well known - so and so many man-hours per part, so-and-so much material, so-and-so many factory square feet. Software was different - or is different. Brooks was a corrective to the idea that if software was late - just add more programmers, like you’d do with a factory line.

                                                                    The fact that Brooks still teaches us these lessons is an indictment of the education of those that plan and lead software developments - or it’s because developers aren’t as easy to push around as factory workers.

                                                                    1. 1

                                                                      Brooks also advocated for a team structure where 80% of people are doing what amount to clerical work, while only one or two are allowed to contribute code to the product.

                                                                      It seems quaintly archaic in a time where modern tooling like Git and CI/CD eliminate so much of that support burden. Hell even the C linter (1978) didn’t exist when Brooks wrote his Imaginary Individual-Increment (1975).

                                                                  1. 3

                                                                    The Lobsters of Old, no?

                                                                    1. 0

                                                                      Eh… sort of the Old Lobsters of old. I mean, the jcs Lobsters, before this current era of gentrification. Yeah, it was a splendid place. and doomed

                                                                      1. 1

                                                                        Hard disagree, the only associations I still have are “somehow pretentious” and “not technical enough”.

                                                                        It’s one of the websites that got recommended all the time but I didn’t manage to even consume content there, much less participate. Maybe just a personal mis-fit though.

                                                                    2. 3

                                                                      I do. It was great.

                                                                    1. 2

                                                                      Backblaze B2 is an excellent, reliable, widely-supported, and relatively cheap option for blob backup storage. Works with tools like arq (OSX, Windows), restic (Linux), rclone, etc.

                                                                      Usually your best bet is to store your personal data in some sort of NAS or attached storage and then mirror to something like B2 off-site, perhaps with encryption for extra peace of mind.

                                                                      I personally find that using rclone with Backblaze B2 is the best for performance and ease.


                                                                      With rclone, you can easily saturate your network uplink and you can do partial/incremental uploads with minimal fuss. You can also configure it to not use you full uplink straightforwardly, to spare the bandwidth for your other home uses.


                                                                      1. 1

                                                                        I’ll check out blackblaze B2 Btw what’s the difference between there personal storage and b2 I’m just can’t buy nas at the moment

                                                                      1. 2

                                                                        How does this compare with something like K&R? I’d like to spend some time really studying C, and am looking for a few quality books to digest.

                                                                        1. 4

                                                                          This post on StackOverflow is a ridiculously good answer to your specific question. I have been going back to it time and time again after refreshing my C knowledge by taking the Harvard/EdX free CS50 course earlier this year.


                                                                          Also, this other SO post is really good for understanding what to look for when researching “modern” C. For example, C99, as a keyword.


                                                                          1. 1

                                                                            Perfect, thank you!

                                                                          2. 2

                                                                            I’m studying C now, I bought K&R and found it great for providing problems to reinforce learning, but because the book is older I felt like I might be missing something. So I’m also reading “Effective C” which came out this year.

                                                                            1. 2

                                                                              Thanks for the rec. I hadn’t heard of Effective C, but just managed to borrow a copy from my library. Seems like a good read.