Just bought a WASD CODE 104 key, cherry MX clear switches, 0.2 noise reduction dampers. It’s my 2nd. I’ve had one at work for ~4 years.

    Currently strugging with The WASD “Skeletor” Vim keyboard which I like from a novelty perspective but I didn’t realize JUST HOW MUCH I rely on backlighting to be able to type less frequently used keys, and the cramped layout is starting to make my wrists hurt.

    1. 1

      I’m pretty chuffed that this exists. I think it could be a really useful tool to gain visibility into what’s happening in any number of network scenarios.

      Found this via someone at work when I asked about what folks use to monitor their personal networks after the latest Plex UDP DDoS exploit made me wonder.

      1. 2

        Weird to put this much work into a programming language but not bother to register a domain for it.

        1. 10

          Looking a little deeper:

          Every type in Teal accepts nil as a valid value, even if, like in Lua, attempting to use it with some operations would cause a runtime error, so be aware!

          This is a bit disappointing for me to read since nils are by far the most common type errors in Lua. I’m definitely open to the idea of putting a little more work into my coding by thinking in types, but the types need to pull their weight! A type system which can’t catch the most common type error feels like a missed opportunity.

          1. 3

            Fwiw the talk mentioned nil safety as a potential future direction.

            1. 2

              While still in semi-early development, Pallene is another alternative with some additional performance benefits.

              White Paper


              1. 3

                Yeah, it looks really promising. IIRC Pallene is developed by the core Lua developers. Unfortunately the documentation in their repo does not have enough detail to determine whether their type system has the same nil problem as Teal’s.

                1. 1

                  One of the things I notice when working in Lua is, I’m sure because of its relatively small developer community (as compared to say Java or Python or C/C++) I find a lot of places where the Lua ecosystem goes right up to the edge of the water and then just … stops.

                  Like, as a for instance, try getting luarocks working on a non *NIX based system. It’s not easy :) I know it’s been done but - not easy.

                  Again this is totally understandable because polish and depth require engineer hours to create and those don’t grow on trees.

                  1. 1

                    I find a lot of places where the Lua ecosystem goes right up to the edge of the water and then just … stops.

                    My perspective on this is that Lua developers tend to have more restraint and recognize that sometimes if you can’t do something right, it’s better not to do it at all.

                    1. 2

                      I appreciate that. I definitely is nice to skip the super annoying “Here are 30 half baked almost implementations of $THING” phase.

                      Like the fact that there used to be about 9000 Python distros for Windows and now there’s essentially 1 mainstream one.

              2. 1

                I didn’t like this either. I appreciate Go have the zero-value idea for basic types, but there is still the nil issue for interfaces and pointers.

                Back in my JavaScript days it was tedious always checking for null values before doing the real work.

                1. 1

                  Unrelated to this, but you may be pleased to know that you can use ?. to safely access values that may not exist in JS. e.g. const name = some?.nested?.obj?.name;

                2. 1

                  Totally agree. This makes me think of all the gyrations Swift goes through to ensure that you’re never using or getting a potentially Nil value unless you really REALLY need it and mean for that to be possible in this circumstance.

                3. 2

                  there is a domain, but not a website: http://teal-language.org

                1. 1

                  Teaching myself how to implement depth/breadth first searches in Python because I’m still struggling with the island counting algorithms exercise I mentioned last week. Right around rewrite #3 I realized I needed to take a giant step back and figure out what was going wrong.

                  This is IMO a strong argument for why semi-formal algorithms training is important. I’d love to find more resources on algorithms that aren’t Comer. I owned the 1st edition of his book but found it to be incredibly hard to penetrate.

                  I see Algorithms by Sedgewick & Wayne is part of my Safari subscription. Maybe I’ll put some time into trying to get through that.

                  1. 2

                    May I suggest MIT OCW as a potential resource?

                    1. 1

                      Introduction to Algorithms requires Mathematics for Computer Science as a pre-requisite, which requires Calculus, which I do not have.

                      My former co-workers are telling me I could probably get by the Math for CS course and not conquer the Calculus dragon and be fairly well prepared for the course.

                      Wish me luck :)

                      1. 1

                        I do believe that most of 6.042 (Math for CS) and 6.006 (Intro to Algorithms) do not require calculus. I don’t recall 6.046 (Design and Analysis of Algorithms) being particularly calculus-laden either, but my memory is fuzzy and unwilling to clarify.

                        If at some point you do wish to slay the calculus dragon, and enjoy watching YouTube videos, there’s a wonderful set of videos by 3blue1brown that gives a very nice introduction to it. Of course, to actually learn it (or anything), the best way is always to do exercises or tasks that require calculus.

                        If you have any questions, feel free to ask (through a lobste.rs message, IRC, email, etc), and I can attempt to answer. No guarantee I’ll give good answers, it’s been a little while and I’m not as adept with mathematics as I’d like to be. However, I find it’s easier for me to learn from talking to other people, than it is for me to learn from staring at a lecture or lecture notes, so I figured I’d extend the offer anyway.

                        Good luck! :)

                      2. 1

                        That is awesome, thank you very much! I think the intro is probably about all I can handle right now :)

                        I actually dream about retiring and taking some of the free open to the public summer session “for fun” courses MIT offers. I worked there for a few years and the community is downright magical - I don’t care what anyone says about institutional rot and fund raising foibles :)

                    1. 12

                      Wow, I think this is the first one of these “what are you doing” threads I’ve posted in since I joined.

                      Well, I should probably be looking for a job, but I’m terribly work averse. I’ll probably be working on my new pet project: The Blind and Low-Vision Unix Users Group. And do I ever have a lot of work to do.

                      1. 2

                        Wow what an exciting find!

                        I’ve been getting back into Linux over the last few years and as a partially blind person I’ve gotta say it’s been a bit of a struggle.

                        The biggest issue plaguing me recently has been This bug in Ubuntu and derivatives which showed up in 19.10 and has been there ever since. Apparently it doesn’t happen on laptops, but on very large screens like mine (I have a 34” monitor) if you turn on the Zoom feature, your mouse pointer leaves little square droppings as it travels across the screen. Pretty hard to work that way.

                        Just signed up to the mailing list. Looking forward to getting involved. Thanks for putting this together!

                      1. 15

                        The “old newspaper” format is very cool and folksy and also as a partially blind person very very hard to read.

                        1. 8

                          The repeated reflowing on load is also rather obnoxious.

                          1. 3

                            Super annoying. Thanks for the report! https://github.com/treenotation/dumbdown/issues/8

                          2. 4

                            also as a partially blind person very very hard to read.

                            Short answer: any specific things you hate and are there reading apps you love?

                            Longer answer: I designed for Scroll to be the most accessible publishing platform ever. Will pull this off by having everything be public domain and the clean Dumbdown/Tree Notation source for every article readily available.

                            The design is to make it easy for readers to “take all the content with you” and consume it with their favorite reader. Think RSS but 100x better, since you actually get the full content in the simplest possible notation and can use whatever tool you want to render it just the way that works best for you.

                            1. 5

                              Short answer: any specific things you hate and are there reading apps you love?

                              Hate is way too strong a word. I have partial vision in one eye at 20/200 vision with a severe astigmatism so my eyeball jumps around a lot. Packing the text into a super dense layout like that makes it nearly impossible for me to actually attain focus on each line in the article, making the layout very hard for me to read.

                              Glad to hear it’s an open platform with flexible rendering though, I’ll definitely take a more careful look, and thanks for sharing!

                              1. 1

                                The design is to make it easy for readers to “take all the content with you” and consume it with their favorite reader.

                                In that case it would be super cool if the static site itself had different viewing options for the same content that people could choose from.

                                The newspaper layour is “cool” but I’d like to be able to switch to a more standard blogging layout with one article at a time, larger font, margins on desktop, table of contents, hyperlinks between related articles, perhaps search, etc. A simple cookie could track my preference for which “viewer” I prefer.

                                1. 1

                                  if the static site itself had different viewing options for the same content that people could choose from.

                                  I wouldn’t be opposed to this.

                              2. 3

                                Totally agree! It would also be really cool, to only have the summary of each article shown. Sadly according to the readme the author is not interested in that…

                              1. 12

                                Hear hear!

                                This is exactly the kind of low slung cognitive hurdle I find really turns me off to any programming language.

                                I think part of my dis-taste stems from the fact that this language was designed so very recently in history of programming languages terms.

                                It’s easy to understand why a language like C has some aspects of its syntax that might not feel immediately natural to modern day programmers, it came into its own 30 years ago on radically different hardware than what we run today.

                                Go doesn’t have that excuse. I feel like its designers revel in this class of abstraction fail - mostly because they’ve been using C forever and their choices don’t present roadblocks to them.

                                Make no mistake, enjoying the experience of using one programming language over another is an inherently subjective thing. For my meager brain and the problems I want and need to solve, I will always choose a programming language that presents a higher level of abstraction to me as a programmer.

                                Thanks for writing this!

                                1. 3

                                  Do you think there is any truth to the following statement?

                                  Abstraction solves all problems except for the problem of abstraction.

                                  If so, do you think this is a problem worth addressing? If so, how? Are there different ways to address it than you would that don’t involve “reveling in abstraction fail”?

                                  1. 5

                                    I don’t see abstraction as a problem. I see it as a solution.

                                    If you’re referring to the performance penalties abstraction tends to impose, then choosing a tool with a lower level of abstraction might well make sense.

                                    So, tool to task, and then no abstraction problem :)

                                    1. 9

                                      If abstraction is never viewed as a problem to you, then you likely don’t share some very basic assumptions made by both myself and likely the designers of Go. But maybe that’s not as fun as snubbing your nose and talking about how instead they “revel in abstraction fail.” And then further go on to speculate as to why they think that way.

                                      1. 7

                                        Your point about shared assumptions is very true.

                                        I tend to enjoy solving problems that aren’t particularly performance intensive, and I enjoy working at a very high level of abstraction.

                                        However clearly there’s another viewpoint that deserves to be heard here, so I’ll try to hunt down some resources around the points you’re making. Actually I just found this Wikipedia article which gives this a bit more flavor and I think I understand it better. Abstraction (phrased as indirection in the article) can cause you to think you’re solving hard problems when in reality you’re just moving them around.

                                        Also I apologize if my poor chose of words offended you. I didn’t intend to snub my nose at anything, and I should have been more careful to strictly personalize the point I was making.

                                        1. 10

                                          Thanks. No apology necessary, I’d just love if we could talk about PL design in terms of trade offs instead of being so reductionist/elitist.

                                          I don’t think your Wikipedia article quite does the idea I’m trying to get across justice. So I’ll elaborate a bit more. The essential idea of “abstraction solves all problems except for the problem of abstraction” is that abstraction, can itself, be a problem. The pithy quote doesn’t say what kind of problem, and I think that’s intentional: abstraction can be at the root of many sorts of problems. You’ve identified one of them, absolutely, but I think there are more. Principally on my mind is comprehension.

                                          The problem with saying that abstraction can cause comprehension problems is that abstraction can also be the solution to comprehension problems. It’s a delicate balance of greys, not an absolutist statement. This is why the “herp derp Go designers have no excuse for ignoring 30 years of PL advancement” is just such a bad take. It assumes PL design has itself advanced, that there’s no or little room for reasonable disagreement because “well they wrote C for so long that their brains have rotted.” Sure, you didn’t say that exact thing, but that’s the implication I took away from your words.

                                          Do you think all abstractions are created equal? I don’t. I think some are better than others. And of course it depends on what you’re trying to do. Some abstractions make reading the code easier. Some abstractions can make it harder, especially if the abstraction is more powerful than what is actually necessary.

                                          There’s another pithy saying, “No abstraction is better than the wrong abstraction.” This gets at another problem with abstraction which is that you can build an abstraction to tightly coupled to a problem space, and when that problem space expands or changes, sometimes fixing a bad abstraction is harder than fixing code that never had the abstraction in the first place. Based on this idea, you might, for example, decide to copy a little code instead of adhering to DRY and building an abstraction.

                                          Performance is probably the biggest problem I have with abstraction on a day-to-day basis, but it seems like that’s one you’re already familiar with.

                                          There are many ways to tackle the problems of abstraction. Go is perhaps on the more extreme end of the spectrum, but IMO, it’s a very reasonable one. If you believe one of the primary motivations for problematic abstractions is the tools available to build abstractions, for example, then a very valid and very reasonable solution to that would be to restrict the tooling. This is, for example, the primary reason why I’ve long been opposed to adding monads to Rust.

                                          I don’t believe this is just limited to programming languages either. The comprehension problem with abstraction can be seen everywhere. When conversing with someone, or reading a book or even in educational materials, you’ll often see or hear a general statement, and that’s quickly followed up with examples. Because examples are concrete and help us reason through the abstraction. Of course, the extent to which examples are helpful or even necessary depends on the person. I’ve met plenty of people who have an uncanny ability to stay in abstraction land without ever coming down on to something concrete. I’m not one of them, but I know they exist.

                                          1. 7

                                            Thank you very much for taking the time to write this up.

                                            Let’s hope I manage to actually learn from this and not succumb to knee jerk mis-scoped reactions in the future.

                                            What’s interesting is that I have a very different reaction to Rust. I feel like Rust brings some very new ideas to the table. It offers a mix of very high and very low level abstractions, but in general offers a much lower level of abstraction than the programming languages I work in regularly and am most familiar with - Python & Ruby.

                                            I think part of my attitude towards Go is rooted in my attitude towards C. It’s an incredible and venerable tool, but one I have stubbed my toe on enough that I find it painful and not enjoyable, and that has perhaps unjustly tainted my perceptions WRT Golang.

                                            1. 5

                                              Here are some opinions I’ve written on Rust vs. Go, although mostly about Go’s poor abstraction facilities and how they inhibit me. https://users.rust-lang.org/t/what-made-you-choose-rust-over-go/37828/7

                                              1. 2

                                                This seems like it would be an interesting read, but unfortunately it doesn’t seem to load?

                                                1. 5

                                                  Works for me. I’ve copied it below.

                                                  I’ve been writing Go ~daily since before 1.0 came out. I’ve been writing Rust ~daily also since before its 1.0 release. I still do. I primarily write Go at work and Rust in my free time these days, although I sometimes write Rust at work and sometimes write Go in my free time.

                                                  Go’s goals actually deeply resonate with me. I very much appreciate its fast compilation times, opinionated and reasonably orthogonal design and the simplicity of the overall tooling and language. “simplicity” is an overloaded term that folks love to get pedantic about, so I’ll just say that I’m using it in this context to refer to the number of different language constructs one needs to understand, and invariably, how long it takes (or how difficult it is) for someone to start becoming productive in the language.

                                                  I actually try hard to blend some of those goals that I find appealing into Rust code that I write. It can be very difficult at times. In general, I do my best to avoid writing generic code unless it’s well motivated, or manifests in a way that represents a common pattern among all Rust code. My personal belief is that Go’s lack of generics lends considerably to its simplicity. Writing in Go code heavily biases towards less generic code, and thus, more purpose driven code and less YAGNI code. I don’t mean this to be a flippant comment; the best of us succumb to writing YAGNI code.

                                                  So if I like Go’s goals so much, why do I use Rust? I think I can boil it down to two primary things.

                                                  The first is obvious: performance and control. The projects I tend to take on in my free time bias towards libraries or applications that materially benefit from as much performance tuning as you want. Go has limits here that just cannot be breached at all, or cannot be breached without sacrificing something meaningful (such as code complexity). GC is certainly part of this, and not just the GC itself, but the affects that GC has on the rest of your code, such as memory barriers. Go just makes it too hard to get optimal codegen in too many cases. And this is why performance critical routines in Go’s standard library are written in Assembly. I don’t mind writing Assembly when I have to, but I don’t want to do it as frequently as I would have to in Go. In Rust, I don’t have to.

                                                  The second reason is harder to express, but the most succinct way I can put it is this: Go punishes you more than Rust does when you try to encapsulate things. This is a nuanced view that is hard to appreciate if you haven’t used both languages in anger. The principle problems with Go echo a lot of the lower effort criticism of the language. My goal here is to tie them to meaningful problems that I hit in practice. But in summary:

                                                  • The lack of parametric polymorphism in Go makes it hard to build reusable abstractions, even when those abstractions don’t add too much complexity to the code. The one I miss the most here is probably Option<T>. In Go, one often uses *T instead as a work-around, but this isn’t always desirable or convenient.
                                                  • The lack of a first class iteration protocol. In Rust, the for loop works with anything that implements IntoIterator. You can define your own types that define their own iteration. Go has no such thing. Instead, its for loop is only defined to work on a limited set of built-in types. Go does have conventions for defining iterators, but there is no protocol and they cannot use the for loop.
                                                  • Default values. I have a love-hate relationship with default values. On the one hand, they give Go its character and make a lot of things convenient. But on the other hand, they defeat attempts at encapsulation. They also make other things annoying, such as preventing compilation errors in struct literals when a new field is added. (You can avoid this by using positional struct literal syntax, but nobody wants to do that because of the huge sacrifice in readability.)

                                                  So how do these things hamper encapsulation? The first two are pretty easy to exemplify. Consider what happens if you want to define your own map type in Go. Hell, it doesn’t even have to be generic. But maybe you want to enforce some invariant about it, or store some extra data with it. e.g., Perhaps you want to build an ordered map using generics. Or for the non-generics case, maybe you want to build a map that is only permitted to store certain keys. Either way you slice it, this map is going to be a second class citizen to Go’s normal map type:

                                                  • You can’t reuse the mymap[key] syntax.
                                                  • You can’t reuse the for key, value := range mymap { construct.
                                                  • You can’t reuse the value, ok := mymap[key] syntax.

                                                  Instead, you wind up needing to define methods for all of these things. It’s not a huge deal, but now your map looks different from most other maps in your program. Even Go’s standard library sync.Map suffers from this. The icing on the cake is that it’s not type safe because it achieves generics by using the equivalent of Rust’s Any type and forcing callers to perform reflection/type conversions.

                                                  Default values are a completely different beast. Their presence basically makes it impossible to reason conclusively about the invariants of a type. Say for example you define an exported struct with hidden member fields:

                                                  type Foo struct {
                                                      // assume there are important invariants
                                                      // that relate these three values
                                                      a, b, c int
                                                  func NewFoo() Foo { ... }
                                                  func (f *Foo) DoSomething() { ... }

                                                  Naively, you might assume that the only way to build Foo is with NewFoo. And that the only way to mutate its data is by calling methods on Foo such as DoSomething. But this isn’t quite the full story, since callers can write this:

                                                  var foo Foo

                                                  Which means the Foo type now exists as a default value where all of its component members are also default values. This in turn implies that any invariant you might want to come up with for the data inside Foo must account for that component’s default values. In many cases, this isn’t a huge deal, but it can be a real pain. To the point where I often feel punished for trying to hide data.

                                                  You can get a reprieve from this by using an unexported type, but that type cannot appear anywhere (recursively) in an exported type. At least in that case, you can be guaranteed to see all such constructions of that type in the same package.

                                                  None of these things are problems in Rust. YMMV over how much you consider the above things to be problems, but I’ve personally found them to be the things that annoy me the most in Go. An honorary mention is of course sum types, and in particular, exhaustive checks on case analysis. I’ve actually tried to solve this problem to some extent, but it’s not ideal for a number of reasons because of how heavyweight it is: https://github.com/BurntSushi/go-sumtype — From my perspective, the lack of sum types just means you can move fewer invariants into the type system. For me personally, sum types are a huge part of my day-to-day Rust coding and greatly lend to its readability. Being able to explicitly enumerate the mutually exclusive states of your data is a huge boon.

                                                  Anyway, Rust has downsides too. But I’m tired of typing. My main pain points with Rust are: 1) complexity of language features, 2) churn of language/library evolution and 3) compile times. Go suffers from basically none of those things, which is pretty nice.

                                            2. 0

                                              It assumes PL design has itself advanced

                                              I think it has in some ways, but it’s as much in figuring out which abstractions are valuable as it is with expanding the scope of what abstractions we can express.

                                              And I think Go provided a really solid catalyst for a lot of good PLT and developer experience improvements in newer programming languages.

                                      2. 3

                                        I think the answer is to have a low level kernel and build up the rest of the language from lower abstraction primitives. Present the highest level layer as the default interface, but provide access to the primitives.

                                        For example, python has IO buffers that it uses to open files, but you normally don’t need to access them to do file work. If you are doing something a bit weird you can drop down to that level.

                                    1. 2

                                      Wasn’t Ultima VIII also the one that on the DOS side required horrible contortions involving memory managers just to get it to run?

                                      1. 2

                                        I think 7 is particularly famous for that. Unlike 8, it’s also famous for being an excellent and groundbreaking game.

                                      1. 1

                                        There was a time when wuarchive and SIMTEL contained 9/10ths of everything good on the internet via FTP :)

                                        Back when there was that one person at every company who knew where EVERYTHING was.

                                        1. 14

                                          My favorite quote from the write-up:

                                          Those who understand the TMDS physical layer are probably screaming, but I was fine, because I did not read the electrical section of the spec until after I got this board working. Then I screamed.

                                          1. 2

                                            So, does the fact that DVI is processed to be electrically “neutral” overall (i.e. balanced 0s and 1s) mean that the capacitors never actually charged much, so they just acted as tiny low value resistors? Maybe?

                                          1. 4

                                            Real life:

                                            Get on the ice and enjoy the snow with our 7yo, it’ll be above 0℃ after Sunday.


                                            • Continue splitting up buildRustPackage in nixpkgs into separate composable hooks, this makes it easier to reuse the same functionality for mixed Rust-Python (or pick another language) packages. (Work done so far: #112500, #112804)
                                            • Improve support for CUDA 11 in nixpkgs.
                                            1. 2

                                              Get on the ice and enjoy the snow with our 7yo, it’ll be above 0℃ after Sunday.

                                              So refreshing to see this. I live in Boston, and get kinda tired of listening to people whine as if the cold and snow were an insurmountable obstacle to be avoided like radioactive waste.

                                              Learn to wear appropriate clothes and enjoy the outside in winter. Revolutionary idea, I know :)

                                            1. 3

                                              I’m resurrecting the old rogue v3.6 code.

                                              This code is undoubtedly the worst code I’ve seen anywhere. Indentation is mix of tabs and spaces (4 spaces for 1 level, 1 tab for 2 levels, 1 tab + 4 spaces for 3 levels), the game’s state is stored on ncurses WINDOWs, dozens of utility functions are scattered all over the place and used maybe once or twice, and its authors don’t seem to know much about .h files and function prototypes (just to name a few defects).

                                              1. 1

                                                Sounds like a fun project!

                                                I’d also guess it’s K&R C so you’ll need to convert to ANSI as well?

                                              1. 3

                                                Finishing the algorithms exercise I’m stuck on - it’s an island counting problem. You get a grid of 1s and 0s and you have to properly count the connected series of 1s.

                                                3 tests are passing but the two trick data set tests - squares and circles, are failing.

                                                One of the things I am loving about Pybites is that for every problem you get a test suite that not only ensures you got AN answer but that you’re also providing for irregular or tricky cases.

                                                This is exactly the kind of algorithmic complexity I need to become WAY more comfortable with.

                                                1. 2

                                                  This problem, and others, can be solved by using official distribution images instead of those provided by the Raspberry Pi project. I’m using the official Fedora 33 ARM64 (aarch64) image for example, works perfectly on my Raspberry Pi 3B+ and has the exact same packages (including kernel!) as the x86_64 version of Fedora.

                                                  See https://fedoraproject.org/wiki/Architectures/ARM/Raspberry_Pi

                                                  1. 3

                                                    Do the distro-originated images come with all the same raspberry-pi configuration, hardware drivers, and firmware gubbins as Raspbian? That’s the main reason I run Raspbian, aside from it having more or less guaranteed support when things break and I need to do some googlin’ to fix it.

                                                    1. 2

                                                      Generally speaking? No.

                                                      Raspbian is the only distro that provides truly first class support for the pi’s hardware.

                                                      Graphics support is becoming more widespread at least, and there are bits and bobs of work happening in various distros.

                                                      But from what I’ve seen most distros are optimizing for a good desktop experience on the pi.

                                                      1. 1

                                                        At least on Fedora you get a kernel very close to upstream Linux, also for the Pi, so no crazy stuff and everything I use works out of the box (LAN, WIFi). That is the reason why the Raspberry Pi 4 for example still doesn’t work in Fedora, requires more stuff to be properly upstreamed: https://github.com/lategoodbye/rpi-zero/issues/43

                                                    1. 3

                                                      I’d like to be able to minimize my relationship with microsoft and talk about how to do so without being called hypocritical because I can’t take it to the level that Richard Stallman does.

                                                      1. 2

                                                        And you can simply by choosing a different distro to run on your Raspberry Pi.

                                                        Pick any one of the gajillion free software only choices out there and be happy.

                                                        The Raspbian folks have made pragmatic choices.

                                                        1. 2

                                                          Sorry, I should have replied directly to the people saying “But Chrome! But Steam!” I make pragmatic choices too, but I’m not giving up entirely yet.

                                                          1. 1

                                                            Adhering to principle is good, but in this case IMO you’re tilting at a windmill.

                                                            If you are rabidly against anything MSFT then there’s no hope, but if you have a reasonable distaste for the non 100% FLOSS version of VSCode why not give VSCodium a whirl?

                                                            Honest to god it’s a really great, capable tool. You don’t have to like it or want to use it to appreciate the value it adds or the contribution it’s made to the programming ecosystem.

                                                      1. 15

                                                        It seems RPi foundation officially recommends MS IDE, and hence this was included Raspberry Pi OS. They should keep this to GUI image for kids or anyone who wish to to learn Python and other stuff using VS Code. Most Linux geeks and power users use RPi as a git server or adblocker and so on as a headless server.

                                                        (my emphasis)

                                                        What an amazing dismissal of the next generation of “Linux geeks and power users”.

                                                        1. 10

                                                          Especially since educational use is explicitly the aim of the Raspberry Pi project

                                                          1. -1

                                                            Got to educate them into dependency on Microsoft IDEs. The younger, the better.

                                                          2. 3


                                                            The implication is that if you’re a Linux geek/power user you wouldn’t go near something like VSCode.

                                                            It’s just utterly wrong headed. I use and love VSCode. It’s a superlative tool. I install the Vim keybindings so I can continue to leverage my years of muscle training, and still use and love Vim on the server.

                                                          1. 8

                                                            I have Very Serious Issues with this article, and they’re typified by the following passage:

                                                            It seems RPi foundation officially recommends MS IDE, and hence this was included Raspberry Pi OS. They should keep this to GUI image for kids or anyone who wish to to learn Python and other stuff using VS Code. Most Linux geeks and power users use RPi as a git server or adblocker and so on as a headless server. There is always a trust issue when unwanted software repo configured and gpg keys are installed secretly, which is the main issue. What other problems Linux users may face:

                                                            From the Raspberry Pi foundation’s mission statement:

                                                            We enable any school to offer students the opportunity to study computing and computer science through providing the best possible curriculum, resources, and training for teachers.

                                                            How is including Visual Studio Code anything other than in service to this goal?

                                                            This is the kind of reactionary behavior that leads me to think parts of the open source community are more interested in heaping derision and generally biting the hand that feeds them.

                                                            1. 6

                                                              They’re not all bad but give nowhere near as much return for the investment of your time.

                                                              This is REALLY unfair.

                                                              Reading a book like Structure and Interpretation of Computer Programs isn’t about delivering a quick hit productivity boost for your developer skills.

                                                              It’s about cultivating a very deep understanding of computation and some of the patterns and tools that can elevate your craft to another level.

                                                              This is an incredibly ham fisted description, but hopefully you’ll get the idea.

                                                              1. 3

                                                                For what it’s worth, as mentioned elsewhere here, I genuinely disagree.

                                                                1. 2

                                                                  I totally get it, and think your point is very valid. SICP is a very high wall indeed for most of us to scale.

                                                              1. 3

                                                                I use https://joplinapp.org/ synced to my Nextcloud instance (WebDAV). Joplin is super awesome, it is quick, search is great, writing and editing notes in Markdown is natural for me. I’ve used Notion in the past and found that it’s slow, the different components/block system actually gets in my way of composing notes. And then, Joplin allows me to take a backup of my data seamlessly.

                                                                With the tool out of the sight, it’s really important to figure out a workflow as well for yourself. There’s no point in finding a good tool and not using it enough (or just forgetting about it in the next few days). Here are few ways I use Joplin:

                                                                For Knowledge Management:

                                                                • Have 2 Notebooks: Work/Personal. (self explanatory)
                                                                • Inside Work, I have multiple sub-notebooks which touch broadly each category of the stuff I do (eg Golang/Ops)
                                                                • I’ve a Scratchpad sub notebook in both Work/Personal and this is actually where I spend most of my time on. During the day or while doing the task, I make it a point to just log down whatever I did to not forget it later (if I think it’s worth saving for future) and not particularly care much about grammar, formatting etc. The idea is to log down as soon and go back to what you were doing. Depending on the workload during the week, I take the Scratchpad and move the entries to their correct categories and format them nicely. This usually happens twice a week (Wed and Sat) but no fixed rule. The idea is inspired from “Inbox Zero”, so at the end of every week I aim to have a clean scratchpad and whatever I’ve learnt during the week goes in correct categories.

                                                                For Bookmarks: One Notebook with multiple sub notebooks with categories like:

                                                                • Articles
                                                                • UI Inspiration
                                                                • Tech Talks
                                                                • etc..

                                                                I use Joplin Web Clipper Extension which allows me to save the entire link (as HTML or just URLs) in these notebooks. Each new entry is a new note, that allows me to also take short notes on that particular URL later (like few notes after watching a tech talk) etc.

                                                                I heavily use Tags in all my notebooks, which allows me to have a unified view of different kind of stuff I’ve. For example “golang” tag in my Work notes and Personal notes, allows me see all the “golang” stuff together in one place.

                                                                This system isn’t ideal/perfect or it may not suit you as well. And I didn’t reach at this workflow from day 1, took me many iterations and experimenting with different tools until I settled on this. And now I think I’m fairly satisfied with this approach. Joplin is <3

                                                                1. 3

                                                                  Just came here to praise Joplin!

                                                                  1. 2

                                                                    +1 for Joplin. It has honestly been a Warp Speed productivity boost for my learning and retention.

                                                                    Realized I should at least try and add some value :)

                                                                    I make heavy use of both notebooks and tags. So I have Tech, Househoud, Gaming notebooks, and about a bazillion tags for every possible attribute, but I can at least restrict my search to the correct sphere, which is especially useful if I know I want a particular thing but can’t successfully retrieve it using a tag search.

                                                                  1. 3

                                                                    This is kind of a cheap shot.

                                                                    I don’t think Wayland is actually even claiming to be a drop in replacement for Xorg. My understanding is that it’s a radical redesign of the way graphics are handled on *NIX which just happens to have fairly good Xorg compatability shims that work for a bunch of use cases.

                                                                    It’s also a perfect example of how Linux distributions offer choice to people so they can make informed decisions about which display stack they want to be running.

                                                                    I’d guess operating systems like *BSD that aren’t married to one or the other offer even more flexibility for their users.

                                                                    Ubuntu is still shipping stock Xorg, Fedora has moved to Wayland. Pick the distro and environment that works for you, make good educated decisions, and avoid partisan rants like this that don’t actually add much value to the overall conversation. That’s my take.