1. 2

    It would have to be the old FSharpx F# OSS project on Github.

    Since then the project has been broken up into smaller pieces. Nuget.org lists 16 different packages, although the project itself was broken into 3 -4 (depending on how you count them) Github repos.

    At the time I was one of the top contributors, and I would still today be one of the top 3 for FSharpx.Collections, except the way the repos were split up all my history ended up in FSharpx.Extras, which I don’t even think I contributed to.

    In fairness to the individual who undertook splitting the repo, at the time I wouldn’t have preserved the Git history correctly either given my state of Git competence then. This was the project that took me from zero Git skills to some competence.

    1. 0

      PostgreSQL is free “as in libertarian”, not free “as in beer”.

      1. 17

        It all started over 11 years ago.

        1. I pulled a hobby C# project off the shelf and realized what I really wanted to do internally was pass functions around, which is a PITA in C#. I heard of this new language, F#, which is supposed to be a functional language. Maybe I should learn that.
        2. Puzzled over the source code of FParsec…which is not the best way to learn F#.
        3. Wrote a crappy program that solved an immediate research problem at work searching through logs of an IMAP server.
        4. Wrote a demonstration of parallel SQL DB reading which would solve a slowness issue with the company’s software.
        5. No hope of introducing F# at this company. Quit my job and went on sabbatical for almost a year learning by writing blog posts and speaking whenever possible.
        6. Met a young entrepreneur at the S.F. F# meetup who just got funding for a start-up and wanted to use F#.
        7. I’ve been working almost exclusively with F# and SQL now for over 7 years.
        1. 4

          Are there any well-known open source .NET apps (CLI or GUI) that run on Linux?

          1. 7

            KeePass.

            Back when Gnome + Mono was a thing lots of interesting stuff was born, eg. Beagle.

            Suse was actively developing nice user facing tools in mono at astonishing pace, then C# fell from favour because of politocs, most stuff was half rewritten in C++/Python/JavaScript, usually in lower quality/featureset.

            Since then I find Gnome worse with every release, but that has not so much to do with .NET support.

            1. 1

              I was using keepass on my windows desktop. When my machine started to die I was pleasantly surprised to find my keepass database worked on debian.

            2. 4

              There are a few Mono apps from back when the Gnome project was kind of adopting Mono as their standard runtime for apps. Two that come to mind are Tomboy (notes app) and Banshee (music player).

              1. 4

                Jellyfin media server (FOSS fork of Emby and alternative to Plex) runs on dotnet.

                1. 4

                  If anything should work on Linux, it should be F#, but here’s a tweet from yesterday from the author of an F# course bemoaning the difficulty he is having getting his course to seamlessly work.

                  https://twitter.com/kitlovesfsharp/status/1362125496683819012

                  1. 3

                    It works fine for me on Fedora. As the comments suggest, it may be related to snap.

                    Ionode is buggy sometimes, but so is Visual Studiofor F#.Both are steadily getting better.

                  2. 3

                    PowerShell for one, but it’s fairly recent that .NET Core got Linux support, so I doubt there are many large projects around yet. Most likely any really large open source projects in the coming years will come from Microsoft open sourcing their own products.

                    1. 2

                      There may be some, but I have been waiting for a bit more maturity in the .Net Core, .Net 5 (and now .Net 6) ecosystems before diving in. A year ago, I was reading a lot of stories about cross platform issues in core and I had my own painful experience setting up .Net Core with Asp.net.

                      I’m actually quite surprised how quickly there is now a .Net 6 version coming out.

                    1. 1

                      The improvements I would like to see over and above what SQL offers just are not compelling enough for anyone except hackers to attempt or even care about. Unless it was delivered to me on a silver platter, I wouldn’t even care.

                      1. Full support of the relational algebra. I think some implementations (PostgreSQL?) do implement relational division. MS SQL does not…you have to write some hacky SQL.
                      2. A native query language that is ordered like the order of operations the server actually implements. I believe LINQ is closest to this, but I would never default to using LINQ because of the overhead.
                      3. A more granular approach to nulls. I haven’t wrapped my head around this in a while, but I believe one can make the case for 2 logical nulls. Better yet would be eliminating nulls for option type.
                      4. Improved type support…better support of user defined types, for instance.
                      1. 1

                        I really miss a good cheap Windows tablet. I used to have one of the very early low-end Surface tablets. It was great for plopping on the couch and surfing the internet, and still let me access the other file systems on my home network and run some applications. But the battery eventually gave out and the damn case was entirely glued. I tried heating the glue, but it wasn’t something I was experienced at and I cracked the screen.

                        1. 4

                          Having seen both the SV and traditional sides of the software engineering experience, an SV company can hire great SEs and still self-sabotage by egotistical young founders who think they know better than the experienced SEs they hired because famous-VC gave them an A round, validating their genius.

                          1. 1

                            I’ve decided the reason I’ve never mastered rebase is because working with small reams on production and OSS projects there is little value in tidy history. For projects involving really large teams this is completely different.

                            1. 2

                              I disagree.

                              Even if there are only 2-3 developers, being able to see the flow of changes going into mainline as discrete feature oriented chunks is immensely helpful when you’re going back through history trying to figure out exactly where something went wrong.

                              1. 2

                                Honestly, I find a lot of use in a tidy history in all projects. Any time that I need to use git log -S, git bisect, git revert, it makes it way easier if the history is tidier. I do use these tools in my personal projects, because they’re v powerful for finding bugs.

                              1. 2

                                Unix ignoramus here, but functional programming enthusiast. I was made aware of NixOS a few months ago and really liked the idea of it. If I ever get around to firing up a *nix computer, I think I would like to try this. Has anyone ever installed on a Raspberry Pi 4?

                                1. 4

                                  I seem to have something about NixOS on RPi4 in my bookmarks: https://lobste.rs/s/pdkwcq/nixos_on_raspberry_pi_creating_custom_sd - though I haven’t tried that myself.

                                  Personally, I only installed Nix on my RPi4 with Raspbian. One thing I had to do to make it work was to switch Raspbian to a 64-bit kernel image. There’s some (theoretically experimental, yet it worked flawlessly for me) flag for this; if I found the right one, I believe you need to put arm_64bit=1 in the RPi4’s /boot/config.txt, then reboot.

                                  Please note, that if you’ve never used Unix/Linux at all before, starting from NixOS might be a rather deep dive. Say, akin to learning car driving by buying a battered used 4x4 and having it delivered into your backyard. It’s definitely doable, and if you like experimenting you’ll definitely have tons of fun and learn a lot, though don’t be surprised if many people might say it’s not the easiest nor most typical way to do that. Depending on what is your vision of fun, you might want to consider going with Ubuntu/Raspbian first, if you prefer smaller and safer steps (i.e. learning in a Chevvy at a driving school) - or, it might be exactly the path to pick if you do like crazy hacker adventure :D (Personally, somewhat recently I did a for-fun project of assembling Android .apk files by hand from scratch, byte by byte, so I can totally relate if you’d like to choose the crazy way ;P)

                                  1. 2

                                    I build SSH-enabled SD images for screen/keyboard-less installation via: https://github.com/Robertof/nixos-docker-sd-image-builder

                                    Someone helpfully provided step-by-step instructions for the builder here: https://gist.github.com/chrisanthropic/2e6d3645f20da8fd4c1f122113f89c06

                                    Things I tripped over initially:

                                    • Increase sdImage.firmwareSize from 128 to something like 1024 if your SD card has the space. If you don’t know what you’re doing you’ll probably want to nixos-rebuild switch a few times which can consume more than the default.
                                    • Prefer to use the AWS ARM instance support via packer if possible - it’s a lot faster than using QEMU. My (very rough) cost estimate is somewhere between 20-40 cents (Euro).
                                    • if you’re using a Pi 4 then make sure you read the instructions thoroughly for Pi 4 specifics. Mainly setting DISABLE_ZFS_IN_INSTALLER=y for build speed and NIXPKGS_BRANCH=master so it works and you don’t just get a very smol Christmas tree with blinking lights.
                                    • If you’re using packer you can directly add access_key and secret_key to the amazon-ebs source, like so:
                                    source "amazon-ebs" "nixos_sd_image_builder" {
                                      access_key = "<...>"
                                      secret_key = "<...>"
                                      ..
                                    }
                                    
                                    1. 2

                                      A word of warning on the new 4b with https://github.com/Robertof/nixos-docker-sd-image-builder

                                      I bought the 8gig model in september, it wouldn’t boot at all. Bought a 4gig model, booted same sd card I created and it worked fine, popped carg back in the 8 and then that booted. You should be ok now as the firmware is more up to date and you can always install a newer firmware but the 8g pi 4 is a bit weird. And not just with nixos i’ve seen lots of reports of similar from other people on the pi forums.

                                      Other than that caveat it works fine, one thing i have to try out is the usb boot from the latest firmware and ditch sd cards entirely for these little pi’s.

                                      1. 1

                                        I’ve used it for two different 8GB Pi 4s in the past month - apart from forgetting to set NIXPKGS_BRANCH=master I’ve had no other problems.

                                    1. 3

                                      I stuck with Amiga from 1986/7 until Windows 95, and the 2 skills I should have picked up I did not. Instead of paying $500 at the time for a proper C compiler I spent it on an Epson 8-pin dot matrix printer. The ARexx language fulfilled all my hobby programming needs. For an editor I latched on early to UEdit, which was ahead of it’s time as a programmable editor. Unfortunately the author passed away too soon, before anyone really caught on to OSS (and before HTTP and the internet revolution), so when VIM was released on a Fred Fish disk it was just more noise to me.

                                      1. 3

                                        proper C compiler

                                        Meant DiceC, back then. The author is Matthew Dillon, which later became Freebsd project lead, then forked it into Dragonfly as random committers insisted in moving forward the wrong way (copying Linux) regarding SMP, and he was ousted from the project for trying to hold that back and design SMP approach properly instead.

                                        1. 1

                                          Was Dice $500 at the time?

                                          1. 2

                                            IIRC, something like that

                                            1. 1

                                              I don’t know, but it was supposedly a cheap (relatively) C compiler. Matt was apparently in high school at the time. Quite enterprising.

                                          2. 2

                                            I’m already forgetting more than just the details from those days, but have a notion that I shared my happiness, anger and hearthache on BBSes using CygnusEd with Thor. Don’t know exactly when I met CygnusEd, nor Arexx or Thor for that matter, but they were all love at first sight. It lasted until summer ’98, when I my studies finished, and my free time vanished almost over night. Powered it on now and again after that, but in 2006 my 1084S monitor finally died, and that was it.

                                            1. 4

                                              ARexx was just the cat’s meow for me at the time. I think in some ways it was a proto-functional language. My Amiga bbs hangout was FAUG, first amiga user’s group I think very early on (like 1987) Donald Knuth popped in on occasion, but I could be wrong. I didn’t know who he was at the time.

                                              1. 2

                                                Modern screens work well with the Amiga, with an OSSC in-between.

                                                1. 2

                                                  Thanks, I suspected as much, but never really checked. Haven’t had time, money or room to do anything with my old A500 or A4000, only cleaned the motherboard of the latter after the battery had leaked out, have to check for damages.

                                            1. 5

                                              Mostly agree, but not assertive enough.

                                              I recommend writing out the full agenda

                                              Published agenda before the meeting (preferably attached to the invites) is a requirement,.

                                              I like the shared notes document. Nice touch for remote meetings, and even in person meetings.

                                              Every meeting should must result in published action item, with assignments.

                                              1. 1

                                                Features that may still make it to F# 5, but the team has not committed to shipping https://github.com/dotnet/fsharp/pulls?q=is%3Aopen+is%3Apr+label%3A%22Candidate+for+F%23+vNext%22

                                                1. 1

                                                  I’m especially looking forward to the Applicative computation expressions. I never caught on to defining operator symbols and coding applicatives that way. I do use a custom computation expression when I need it. A standard computation expression in the language will be nicer to have.

                                                  I know the Microsoft F# team is working hard to get this Extension members visible to trait constraints fix into the release as well. It apparently is not easy. https://github.com/dotnet/fsharp/pull/6805

                                                  1. 2

                                                    Cleaned-up my Typed SICM project over the weekend. This is an implementation of the untyped Scheme code in Sussman and Wisdom’s Structure and Interpretation of Classical Mechanics to typed F#.

                                                    I think I can now complete chapter 1 and (if I live long enough) the whole book with F#. A lot of noisy boiler plate in the repo, the only files that matter are https://github.com/jackfoxy/TypedSicm/blob/master/src/TypedSicm/TypedSicmPrelude.fs Most of the code in this file is type Scalar and supporting code, my experiment with generic arithmetic, which is completely unnecessary for this project. (I’m entertaining suggestions for better name than “scalar”.) Sussman and Wisdom, Structure and Interpretation of Classical Mechanics (MIT, 2014), 16 n, 509.

                                                    https://github.com/jackfoxy/TypedSicm/blob/master/src/TypedSicm/Ch1LagrangianMechanics.fs The actual typed SICM code, comparing Sussman’s Scheme to typed F#. I think F# now wins on conciseness and readability.

                                                    https://github.com/jackfoxy/TypedSicm/blob/master/src/TypedSicmConsole/Program.fs Executes the first 2 tests (from the book).

                                                    I put together a F# language suggestion https://github.com/fsharp/fslang-suggestions yesterday to implement generic arithmetic. That was my purpose in over-engineering the generic arithmetic in this project. I’m soliciting feedback from colleagues before I submit it .

                                                    1. 2

                                                      As someone who developed a boyhood interest in the navy, and followed current and historical naval matters ever since, it’s sad to say the U.S. Navy has lost its way. That really came home when they dropped the surface warfare school almost all the fleet officers had to attend. It was an actual physical 6 month school with labs & field trips. Now that the navy has such a good pipeline from elite universities they can just throw a video course at young officers while deployed on surface warfare ships at sea.

                                                      1. 17

                                                        For me, it’s the “bundling” situation. I’ve never worked on a production project where “the webpack” wasn’t the most hated part of the stack. Webpack’s source code is a rat’s nest, so I feel very unmotivated to understand the situation or improve it from within. There’s tons of projects in this space that seek to simplify, but they never seem low-risk enough to migrate to: what if I actually do need to customize?

                                                        So, I’ve been stuck with webpack pains for far too long. Maybe Airbnb or Facebook will open-source their Metro (FB bundler used for React Native) configs one day and we can escape…

                                                        1. 7

                                                          at $WORK we have swapped to Rollup for most of the browserland stuff I work with because it’s so much less headache, the entire codebase is grokable, and you can trivially extend it to do custom stuff if needed.

                                                          I do agree bundling is problematic, but for me the worst part is Babel. I’d rather write ES5 than work with Babel and their constant breaking changes everytime I upgrade something.

                                                          1. 3

                                                            I seldom do front-end work, but bundling is my biggest frustration. Yeah, how come I do what I think is the exact same set up for a new project, and webpack fails me. Sometimes I yarn a particular version, it works, sometimes it doesn’t. Sometimes install –dev sometimes not. Eventually get the new project working, but never know how. Repeatability seems illusive.

                                                            1. 1

                                                              Babel could be all or some of my problems as well…

                                                            2. 2

                                                              Parcel has been nice to work with wrt packaging

                                                              1. 1

                                                                very astute observation. The whole build pipeline for non-trivial webapps is just slightly better than the world of no-packages (eg like C++).

                                                                FB’s metro perhaps is also not a panacea, it does not let me, for example, have source files in directory folders I want (instead it is tied to node’s source file search algorithm).

                                                                1. 1

                                                                  From the outside, I have a bit of trouble even understanding what bundling is all about. What does Webpack to that Grunt doesn’t? And then, what does Grunt do that make doesn’t?

                                                                  1. 6

                                                                    While you can bundle with both Grunt and Webpack, they are entirely different approaches to the problem, and unless you are working on something with only trivial Clientside JS, Webpack’s approach is superior.

                                                                    In short, Webpack (and other modern bundlers) understands require and import statements, so once it is given the location of your entrypoint JS, it walks the dependency tree to convert all needed dependencies into an optimized bundle for the browser. With Grunt, you can provide a list of files, but you need to manually manage the order of any cross-file dependencies, because it will fundamentally only concatenate the files together.

                                                                    1. 1

                                                                      I’ll just add that this even a non-“trivial Clientside JS” project can pull this off well enough with grunt, but when you get to a big project with many people most of which have no idea what is all this about, it becomes a problem.

                                                                1. 5

                                                                  Purely Functional Data Structures - Chris Okasaki 1998 You can also find the same-named PhD thesis on the web. This book is not really highly practical, but it has been a gateway to functional programming for many people, including myself. This book gets you thinking in terms of algorithms using recursion and where the cost is in recursive algorithms (basically more lines = more cost!).

                                                                  1. 37

                                                                    There are a lot of bad takes in here. It sounds like this person is angry at young programmers, not trying to help them.

                                                                    1. 4

                                                                      While I think many of the Falsehoods (some set of people) Still Believe lists convey useful actionable information, this one not so much. It feels way heavier in sarcasm than the more useful lists.

                                                                      1. 4

                                                                        I didn’t take this as angry at all. Do you feel personally attacked by the list?

                                                                        1. 9

                                                                          Not in the slightest - in fact I empathize with the author in a few places, albeit probably for different reasons. Plainly, this post is condescending and makes harmful generalizations about young programmers.

                                                                          Edit: “stereotypes” is probably a better word than “generalizations” here

                                                                          1. 4

                                                                            I know people who have graduated with CS degrees in their 40s.. so, generalizations.

                                                                            1. 8

                                                                              You know that, I know that. Does this author?

                                                                              They are good at multi-tasking, as is evident from their ability to take notes in class and check Facebook at the same time..

                                                                            2. 4

                                                                              I didn’t take it that way. I took as a slightly exasperated but in-good-fun calling out of common problems.

                                                                              I think it’s more likely to help than harm.

                                                                              1. 1

                                                                                I think you’re probably taking it way too seriously

                                                                                1. 1

                                                                                  I would say “inaccurate” rather than “harmful” - lots of accurate generalizations about groups are harmful or perceived as harmful. The problem with a line like “TED talks are Science(TM) and the information presented is accurate.” is that there’s no particularly good reason to believe that graduating CS students are more likely than other demographics to view TED talks as accurate, unbiased sources of information, not that if this were the case people should feel obligated not to say so in order to prevent some kind of harm coming to graduating CS students as a class.

                                                                            1. 3

                                                                              Scheme: I’ve never actually programmed in Scheme or any Lisp dialect. I’ve just learned to read it well enough to follow along in SICP and SICM. I find it beautiful and ineresting, and Sussman uses it brilliantly to convey his ideas. Here’s the problem, nothing in the language specification requires it to be readable for humans. We depend on the author judiciously inserting white space, line breaks, spaces, tabs. This is a convention, not a requirement of the parser or compiler/interpreter. Even when well-formatted, I still find longer snippets difficult to read. I don’t care for the blizzard of parentheses.

                                                                              F#: This has been my go-to language for over 6 years. I have 2 problems with it: 1) Too much of the Microsoft F# team’s valuable time has been wasted in the past keeping it compliant with changes to C#. Ironically most recently this had to do with C# nullable types, which was an attempt to catch up C# with F#. 2) The temptation to do overly-sophisticated things with the F# type system is just too great. The type system is good, but not that good, and improving it and cleaning up existing issues, like the problems with statically resolved types (basically making SRTPs more useful), is often hindered by problem 1.

                                                                              1. 3

                                                                                I’m glad I don’t work in C# anymore. It was once a nicer version of Java with a powerful library, but it’s slowly but surely turning into a managed version of C++ (but maybe I’m the only one who feels that way; I surely like little languages).

                                                                                1. 2

                                                                                  No, I agree.

                                                                                  Some people seem to think that adding more features improves a language.

                                                                                  1. 2

                                                                                    I watch C# language development from the sidelines now. I’ve worked with nothing but F# and SQL for almost 6 years. I agree. From my perspective there is runaway feature bloat…much of it trying to incorporate F# and ML family functional features. The nullable reference type I think is just monstrous. I doubt it will be much incorporated in legacy maintenance. The worst thing, from my perspective, is the Microsoft F# team had to expend valuable time making F# compatible with the new .NET nullable type, something totally useless for F# and only for C# interop. It could be years before such interop even shows up in the wild.

                                                                                    1. 2

                                                                                      I disagree with this.

                                                                                      The following is a list of C# 6 and 7 features that I regularly use in my projects.

                                                                                      • read-only autoproperties - most of the classes I write are immutable.
                                                                                      • autoproperty iniitializers - minor quality of life improvement
                                                                                      • expression bodies - forwarding methods and properties, declaring constructors in a single line
                                                                                      • string interpolation - overriding ToString()
                                                                                      • index initializers - nested dictionaries
                                                                                      • out variables - int.TryParse(), third party APIs
                                                                                      • throw expressions - guard clauses
                                                                                      • discards - third party APIs
                                                                                      • local functions - reducing duplicate code in catch clauses, eager precondition checks in iterator methods
                                                                                      • null conditionals - third party APIs
                                                                                      • nameof - assertions, binding, reflection
                                                                                      • tuple deconstruction - required for the one-line constructor idiom
                                                                                      • pattern matching - type checks for third party APIs

                                                                                      Many of the C# 7 additions don’t apply to my work but I still prefer it to C# 6.

                                                                                      I dislike the in keyword for readonly ref arguments but have no other complaints.

                                                                                      1. 1

                                                                                        I’ve been working with C# for few years now, and I totally agree.

                                                                                        It was a nicer Java, with some useful stuff (LINQ, generators aka. yield return, properties), and now the features they keep adding are all half-assed, half-complete monstrousities breaking not only interop with other languages, but C# semantics itself (async make LINQ and generators unusable, and is spreading like cancer through a codebase. It only makes you unable to reason about your code, to be honest. You don’t know how and where task is scheduled, etc.).

                                                                                        Meanwhile more and more features are being added, but records are not added, nor is support for generatd equality comparision and hashcode added via annotations (see Lombok @Data in Java world), because there will be records sometime.

                                                                                        This was what I’ve been laughing about the Java world: missing features were either ideologized, either were already done, we ere only waiting for the next Java release (since long years, and a few had to pass still for it to arrive)

                                                                                        I’m very disappointed, especially as I see that Java is being mismanaged by Oracle as well. I can only hope something better will come eventually, as I’d prefer f the future were not JavaScript.