1. 1

    That is a lot of Language Implementation Approaches.

    1. 1

      Alots are known for their superior programming abilities.

    1. 4

      Yeah, the metaphor here is totally lost on me.

      Squirrel is far more than the chicken of the trees - it’s quite plainly the best meat there is, and my favorite dish next to lamb.

      I make a recipe similar to this one often. Just looking at those pictures makes me hungry!

      Somehow this completely ruined the article, because for me (and everyone else I know), squirrel is absolutely delicious!

      1. 4

        Despite the title, the issue with the burger in the article is not so much that it’s a squirrel burger, but that it’s roadkill of unknown freshness.

        For me, the part where the analogy breaks down is when the customer/manager, having eaten the roadkill burger, comes back to the person who supplied it and expects them to produce burgers of known and socially acceptable origin for the same price. Maybe the conclusion shouldn’t be, “don’t serve your boss squirrel burgers”, but “if you serve your boss squirrel burgers and they come back for more, you need to find a better boss…”. However, you can’t make a career out of successfully identifying good managers by getting them to fire you for low quality work, so that brings us back to “don’t serve your boss squirrel burgers”, but for different reasons to those in the article.

        1. 1

          Squirrels are more like rats than they are chicken. Their good reputation is due to their fluffy tails but them eating not only seeds is often overlooked.

          1. 1

            I’m sure their diet has something to do with the quality of the meat.

        1. 5

          Summary:

          “Out of the twelve functions analysed, seven of them were fully proven and the rest had few missing proof obligations: two functions had one, one function had two and two functions had more. In total, 1208 proof obligations were automatically generated including 241 safety verification conditions that cover memory and integer safety. 1194 of these were proven and only 14 which constitute 1.2% of the total number were not proven.

          No issues were detected in the code which is not surprising given the safety and reliability record of OpenBSD despite the pitfalls of C language in terms of security issues. Some minor issues and areas that possibly needed more clarification were highlighted for the documentation.”

          1. 1

            That’s actually why I didn’t save or submit the paper back when I found it. It’s still interesting. I just thought author picked bad functions to verify given they’re highly-used, simple, and would contain the errors OpenBSD devs are good at finding. I figured they found all the bugs in it already. Conclusion confirmed that.

            Best route for using formal methods on a project like OpenBSD is to first determine which kind of bugs they’re knocking out regularly vs getting hit with often. They’re good at mitigating and finding the mistakes that would’ve happened in the string operations, esp like overflows. They keep having NULL dereferences, use-after-frees, and so on. Temporal errors. Using or developing techniques for finding those will help them out a lot.

            If looking for stuff like overflows, best to aim the formal methods at new code that just came in. It will have had less review. Preferably in something critical like filesystem, network stack, or VMM. The new VMM really needs anything people can throw at it since it does a tough job of containing potential malice or just out-of-control VM’s.

            1. 4

              I just thought author picked bad functions to verify given they’re highly-used, simple,

              Well try finding functions with the following requirements:

              The following were the unsupported C features of the Jessie plug-in at the time of the writing [24]:

              • Arbitrary gotos. Some simpler forward gotos are allowed.
              • Function pointers.
              • Arbitrary casts. There was some experimental support for casting between pointers (except in specifications).
              • Union types.
              • Variadic functions.
              • Floating point computations.

              The list definitely got smaller for software verification since then. But sadly it is still there.

              My bachelors thesis is about finding already known bugs (the erratas) with CPAchecker in OpenBSD. And a lot of effort went into making the tool understand the OpenBSD quirks until I didn’t have enough time anymore. Only three more weeks! If something useful comes together I will post it on lobsters.

              1. 1

                It’s tricky. The first rule of high-assurance projects in the past was doing your formal specs and algorithms in easiest-to-verify way. The technique I’d use is rewriting the code to use easier-to-analyze constructs with equivalence check and/or tests. Then, apply the verification tools. If problems are found, inspect the original code to be sure they had them. Floating-point is an exception to this but there’s tools for handling it coming online. There’s a lot of R&D in that right now for both automated and manual proofs. One paper also had a type system for safe casts, too, where you only verify the risky ones.

                “My bachelors thesis is about finding already known bugs (the erratas) with CPAchecker in OpenBSD.”

                Interesting. That’s a good way to empirically verify or reject the claimed effectiveness of the tools, too. On top of showing them where they need to improve on it. Good luck. I look forward to reading it when you post it here. :)

              2. 2

                Best route for using formal methods on a project like OpenBSD is to first determine which kind of bugs they’re knocking out regularly vs getting hit with often.

                Some time ago I aggregated bugs from OpenBSD errata to a single table with bug classes. Perhaps it would be useful for you.

                If looking for stuff like overflows, best to aim the formal methods at new code that just came in.

                Formal verification is a complex and time consuming task. Using it for a new code can be a waste of time. AFAIK the most popular practice is stabilizing functionality with testing and then then applying formal methods.

                1. 1

                  re table. Thanks. Bookmarked it.

                  re verification. You caught me slipping since that’s normally my advice. I should’ve clarified by new that I meant “newer” code that just hasn’t been in the kernel long. How new varies with effort required. So, static analysis with low, false positives should be aimed at all code in the repo that passed functionality tests. Stuff involving writing contracts could go into new stuff that shouldn’t change really fast. Full, formal verification should only be done on stuff that’s critical and staying for a long while.

                  That distinction is also why I push for memory-safe languages with contracts. There’s hardly any effort upfront to keep it secure. Rust’s borrow checker might be an exception. They report it gets easier after a learning curve. Contracts can be as simple as ranges to at least stop overflows and test boundary conditions better. In any case, using better tools than C also helps. I’m not going to try selling them on that yet.

            1. 2

              Previously:

              We will be able to evaluate a i.MX 8M pre-production board November 2017 Our extended community can evaluate a handful of i.MX 8M sample chips in November 2017 More evaluation boards should be available before year-end 2017 In Q1 of 2018 we can get i.MX 8M into production. This is well ahead of our required hardware selection date of April 2018, so we will very likely be using the i.MX 8M in the Librem 5.

              Why again did they want to use this unreleased hardware? I don’t understand what would be wrong with something that was already out there. People interested in such a niece phone propably would be able to make it run on 20 year old hardware. (Can’t carry that in your pocket tho?)

              Additionally I don’t understand the huge investment in DE- and UI-support before having the actual hardware. Wouldn’t just getting the hardware and patching it later make more sense?

              1. 3

                “ make it run on 20 year old hardware”

                One of my security-focused designs did copy 20 year old hardware. Shown the picture for concept, most people that like freedom and privacy didn’t like it that much. Almost nobody was interested in one that large despite benefits like extra chips and EMSEC. So, 20 year is probably overstating it. ;)

                1. 1

                  people that like freedom and privacy didn’t like it that much

                  You probably forgot the marketing team and empty promises.

                  1. 2

                    Oh yeah. You just described most security, industry vendors very well. One of main reasons I’m not in security industry is I refused to bullshit people. Almost everything they were selling wouldn’t get the job done. The stuff that would (more often) wasn’t as pretty, profitable, or (if profitable) having high growth. So, I just don’t participate in the bullshit.

                    1. 1

                      It doesn’t matter how much marketing you have, people aren’t going to buy crappy old technology.

                      I’d rather have no phone at all than a ‘secure’ Nokia 9000.

                1. 1

                  I am currently only working on a single project, therefore a ‘grep -r xxx .’ Does the thing. I also have a notebook by MUJI and I just today compared my notes with my source comments. 100% consistency. Kinda feels like a waste of time. But somehow it’s nice to have the same info/task in different representations. Rearranging them and changing them is easier in the notebook. But my notebook doesn’t have VCS and comparing progress is different.

                  1. 4

                    Never heard of it, but it seems like a super interesting approach to interactive environment. I cannot help but remember this Bret Victor’s talk about how we have been programming in almost-anachronistic ways with no innovation in the interfaces.

                    1. 8

                      There’s nothing obsolete about text. Visual languages don’t work. They’ve been tried hundreds of times, to no avail, because GUIs are fundamentally bad user interfaces for experienced users. Text is a better interface for power users, and programming languages are for power users.

                      1. 14

                        Why can’t I re-sort the definitions in my source instead of scrolling around then? Why is it hard to see a dependency graph for all my functions? Why do I have to jump between files all the time? Text - an interface for linear presentation of information - is fundamentally a kludge for code, which is anything but linear.

                        1. 1

                          Why can’t I re-sort the definitions in my source instead of scrolling around then?

                          Sort them by what? It wouldn’t be difficult to write a script using the compiler module of Python to reorder the declarations in your file in an order you chose, which you could then use to replace the text of a buffer in your text editor. But usually I’d suggest what you want is to see a list of definitions in a particular order, which you could then use to jump to the definitions.

                          In every case that I’ve seen of not using plain text, it inevitably become inscrutable. What is actually in my Smalltalk/Lisp image? What is actually there? What can people get out of it later when I deploy it?

                          Why is it hard to see a dependency graph for all my functions?

                          Because nobody has written something that will take your source files, determine their dependencies, and produce the DOT output (a very popular text-based format for graphs, far superior in my opinion to any binary graph description format) for that graph? It’s not like it’s particularly difficult.

                          Why do I have to jump between files all the time?

                          Because it turns out it’s useful to organise things into parts. Because it turns out it’s useful to be able to parallelise compilation and not reparse every bit of code you’ve ever written every time you change any part of it.


                          I think that it’s definitely a requirement of any decent programming language to have a way to easily take the source code of that programming language and reify it into a syntax tree, for example. That’s very useful to have in a standard library. In Lisp it’s just read, Python has more complex syntax and requires more machinery which is in a standard library module, other languages have similar things.

                          One point might be: maybe you don’t need a dependency graph if you can just make your code simpler, maybe you don’t need to jump around files much if your code is properly modularised (and you have a big enough screen and narrow enough maximum line length to have multiple files open at once), maybe sorting your definitions is wrong and what you want is a sortable list of declarations you can jump to the definitions.

                          Not to mention that version control is important and version controlling things that aren’t text is a problem with conventional version control tools. Might not be an issue, you have your own VCS, but then you enter the land of expecting new users of your language to not only not use their standard editor, but also to not use their standard VCS, not use their standard pastebin, etc. How do you pastebin a snippet of a visual language so someone on an IRC channel can see it and give you help? How do you ask questions on StackOverflow about a visual language?

                          It’s not even an issue of them being unusual and unsupported. By their very nature, not using text means that these languages aren’t compatible with generic tools for working with text. And never will be. That’s the thing about text, rather than having many many many binary formats and few tools, you have one binary format and many many tools.

                          1. 8

                            Hey Miles, thanks for elaborating. I think we could have more interesting discussions if you give me a bit more credit and skip the trivial objections. You’re doing the same thing you did last time with C++ compilers. Yes, I know I could write a script, it’s not the point. I’m talking about interactive tools for source code analysis and manipulation, not a one-off sort.

                            I don’t agree with your objections about parallel compilation and parsing. It seems to me that you’re just thinking about existing tools and arguing from the status quo.

                            Further down, you make a suggestion which I interpret as “better languages could mitigate these issues” which is fair, but again I have to disagree because better languages always lead to more complex software which again requires better tools, so that’s a temporary solution at best.

                            You also raise a few objections, and here I should clarify that what I have in mind is not some kind of visual flowchart editor. What I’m claiming is that the conflation of internal representation and visual representation for code is counterproductive, but I think that a display representation that mostly looks like text is fine (as long as it’s actually within a structured editor). What I’m interested in is being able to manipulate symbols and units of code as well as aspects of its structure rather than individual characters.

                            Consequently, for pastebin or StackOverflow, you could just paste some text projection of the code, no problem. When it comes to VCS, well, the current situation is quite poor, so I’d welcome better tools there. For example, if there was a VCS that showed me diffs that take into account the semantics of the language (eg like this: https://www.semanticmerge.com), that would be pretty cool.

                            For the rest of your objections, I offer this analogy: imagine that we only had ASCII pictures, and none of this incompatible JPG/PSD/PNG nonsense with few complicated tools. Then we could use generic tools for working with text to manipulate these files, and we wouldn’t be constrained in any way whether we wanted to create beautiful paintings or complex diagrams. That’s the thing about text!

                            I think the practitioners and particularly academics in our field should have more sense of possibilities and less affection for things the way they are.

                            1. 1

                              When it comes to VCS, well, the current situation is quite poor, so I’d welcome better tools there.

                              Existing VCS could work reasonably well if the serialisation/“text projection” was deterministic and ‘stable’, i.e. minimising the amount of spurious changes like re-ordering of definitions, etc. As a first approximation I can imagine an s-expression language arranging the top-level expressions into lexicographic order, spreading them out so each sub-expression gets its own line, normalising all unquoted whitespace, etc. This would be like a very opinionated gofmt.

                              If users wan’t to preserve some layout/etc. then the editor can store that as metadata in the file. I agree that semantics-aware diffing would be great though ;)

                              1. 1

                                So you always end up separating the storage format from display representation in order to create better tools, which is exactly my point.

                                1. 1

                                  Yes, I agree with your points. Was just remarking that some of these improvements (e.g. VCS) are easier to prototype and experiment with than others (e.g. semantics-aware queries of custom file formats).

                              2. 1

                                The way I see it is that there are tools for turning text into an AST and you can use them to build the fancy things you want. My point wasn’t ‘you can write that sort as a one-off’. You can edit code written in a text-based programming language with a really fancy editor that immediately parses it to an AST and works with it as an AST, and only turns it into text when written to disk. I have no problem with that. But really you’re still editing text when using something like paredit.

                                Something like vim but where the text objects are ‘identifier’, ‘ast node’, ‘expression’, ‘statement’, ‘logical line of code’, ‘block’, etc. rather than ‘text between word separators’, ‘text between spaces’, ‘line’, etc. would be a useful thing. In fact, you could probably do this in vim. I have an extension I use that lets you modify quotes around things taking into account escaped quotes within, etc. That’d probably work way better if it had that default structure for normal text and then could be customised to actually take into account the proper grammar of particular programming languages for which that is supported.

                                What I’m concerned about is the idea that it’s a good idea to store code in a proprietary binary file format that’s different for every language, where you can’t use the same tools with multiple languages. And then having to reimplement the same basic functionality for every single language in separate IDEs for each, where everything works slightly differently.

                                I do find it useful that I can do ci( and vim will delete everything inside the nearest set of parentheses, properly taking into account nesting. So if I have (foo (hello 1 2 3) bar) and my cursor is on the a, it’ll delete everything, even though the nearest ( and ) are beside hello and not foo. That kind of thing, more structured editing? I’m all for that.

                                Consequently, for pastebin or StackOverflow, you could just paste some text projection of the code, no problem. When it comes to VCS, well, the current situation is quite poor, so I’d welcome better tools there. For example, if there was a VCS that showed me diffs that take into account the semantics of the language (eg like this: https://www.semanticmerge.com), that would be pretty cool.

                                Ultimately I think if you have a recognised standardised text projection of your code, you might as well just make that the standardised format for it, then your fancy editor or editor plugin can parse it into the structures it needs. This helps ensure you can edit code over SSH, and have a variety of editors compatible with it, rather than just the single language-designer-provided IDE.

                                One of the nice things about git is that it stores snapshots internally rather than diffs. So if you have a language-specific tool that can produce diffs that are better due to being informed by the grammar of the language (avoiding the problem of adding a function and the diff being ‘added a new closing brace to the previous function then writing a new function except for a closing brace’, for example), then you can do that! Change the diff algorithm.

                                For the rest of your objections, I offer this analogy: imagine that we only had ASCII pictures, and none of this incompatible JPG/PSD/PNG nonsense with few complicated tools. Then we could use generic tools for working with text to manipulate these files, and we wouldn’t be constrained in any way whether we wanted to create beautiful paintings or complex diagrams. That’s the thing about text!

                                Well I mean I do much prefer creating a graph by writing some code to emit DOT than by writing code to emit PNG. I did so just the other day in fact. http://rout.nz/nfa.svg. Thank god for graphviz, eh?

                                Note that there’s also for example farbfeld, and svg, for that matter: text-based formats for images. Just because it’s text underneath doesn’t mean it has to be rendered as ASCII art.

                                1. 1

                                  Cool, I’m glad we can agree that better tools would be good to have.

                                  As far as the storage format, I don’t actually have a clear preference. What’s clearly needed is a separation of storage format and visual representation. If we had that, arguments about tabs vs spaces, indent size, let/in vs where, line length, private methods first or public methods first, vertical vs horizontal space (and on and on) could be nullified because everybody could arrange things however they like. Why can’t we have even such simple conveniences? And that’s just the low hanging fruit, there are far more interesting operations and ways of looking at source that could be implemented.

                                  The other day there was a link to someone’s experiment (https://github.com/forest-lang/forest-compiler) where they use one of the text projections as the storage format. That might work, but it seems to me that the way parsing currently happens, there’s a lot of unnecessary work as whole files are constantly being reparsed because there is no structure to determine the relevant scope. It seems that controlling operations on the AST and knowing which branches are affected could be a lot more efficient. I’m sure there’s plenty of literature of this - I’ll have to look for it (and maybe I’m wrong about this).

                                  What I’m concerned about is the idea that it’s a good idea to store code in a proprietary binary file format that’s different for every language, where you can’t use the same tools with multiple languages. And then having to reimplement the same basic functionality for every single language in separate IDEs for each, where everything works slightly differently.

                                  I understand your concern, but this sounds exactly like the current state of affairs (other than really basic stuff like syntax highlighting maybe). There’s a separate language plugin (or plugins) for every combination of editor/IDE and language, and people keep rewriting all that stuff every time a new editor becomes popular, don’t they?

                                  One of the nice things about git is that it stores snapshots internally rather than diffs.

                                  Sure, we can glean a bit more information from a pair of snapshots, but still not much. It’s still impossible to track a combination of “rename + change definition”, or to treat changes in the order of definitions as a no-op, for example. Whereas if we were tracking changes in a more structured way (node renamed, sub-nodes modified etc.), it seems like we could say a lot more meaningful things about the evolution of the tree.

                                  Thank god for graphviz, eh?

                                  Perhaps the analogy was unclear. Being able to write a set of instructions to generate an image with a piece of software has nothing to do with having identical storage format and visual representation. If we approached images the same way we approach code, we would only have ASCII images as the output format, because that’s what is directly editable with text tools. Since you see the merits of PNG and SVG, you’re agreeing that there’s merit in separating internal/storage representation from the output representation.

                                  1. 1

                                    What I’m concerned about is the idea that it’s a good idea to store code in a proprietary binary file format that’s different for every language

                                    I might have missed something, but I didn’t see anyone proposing this.

                                    In particular, my understanding of Luna is that the graphical and textual representations are actually isomorphic (i.e. one can be derived if given the other). This means we can think of the textual representation as the being both a traditional text-based programming language and as a “file format” for serialising the graphical programming language.

                                    Likewise we can switch to a text view, use grep/sed/etc. as much as we like, then switch back to a graphical view if we want (assuming that the resulting text is syntactically valid).

                              3. 1

                                Tools that improve navigation within textual source have existed for a long time. I’ve been using cscope to bounce around in C and Javascript source bases for as long as I can remember. The more static structure a language has, the easier it is to build these tools without ambiguity. The text source part isn’t really an issue – indeed it enables ad hoc tooling experiments to be built with existing text management tools; e.g., grep.

                                1. 4

                                  Those tools aren’t text, though. They’re other things the augment the experience over just using text which becomes an incidental form of storage. Tools might also use AST’s, objects, data flows, constraints, and so on. They might use anything from direct representation to templates to synthesis.

                                  I think the parent’s point was just text by itself is far more limited than that. Each thing I mentioned is available in some programming environment with an advantage over text-driven development.

                                  1. 1

                                    I think it’s wrong to say that the text storage is incidental. Line-oriented text files are about the lowest common denominator way we have to store data like this.

                                    For starters, it’s effectively human-readable – you can lift the hood up and look at what’s underneath, understanding the effect that each individual character has on the result. Any more complicated structure, as would be generally required to have a more machine-first structured approach to program storage, is not going to have that property; at least not to the same extent.

                                    If this thread demonstrates anything, it’s that we all have (at times, starkly!) different preferences for software engineering tools. Falling back on a textual representation allows us to avoid the need to seek consensus on a standard set of tools – I can use the editor and code manipulation tools that make sense to me, and you can stick to what makes sense to you. I think a lot of the UNIX philosophy posturing ends up being revisionist bunk, but the idea that text is a pretty universal interface for data interchange isn’t completely without merit.

                                    1. 6

                                      The under-the-hood representation is binary-structured electricity that gets turned into human-readable text by parsing and display code. If already parsing it and writing display code, then one might just as well use a different encoding or structure. Text certainly has advantages as one encoding of many to have available. Plugins or input modules can take care of any conversions.

                                      Text does often have tooling advantages in systems like UNIX built with it in mind, though.

                                      1. 1

                                        I think it’s a reductionist argument for the good-enough, hard earned status quo. I think it can be valid, but only within a very narrow perspective - operational and short term.

                                        To my mind, your position is equivalent to this: we should only have ASCII images, and we don’t need any of that PNG/JPG/PSD stuff with complicated specialised tools. Instead, we can use generic text tools to make CAD drawings, diagrams, paintings - whatever. All of those things can be perfectly represented in ASCII, and the text tools will not limit us in any way!

                                    2. 2

                                      I want to search my code like a database, e.g. “show my where this identifier is used as a parameter to a function” - the tooling for text doesn’t support this. Structured tooling would be super useful.

                                      1. 2

                                        Many things can be “queried” with grep and regular expressions. Which is also great to find “similar occurrences” that need to be checked but are only related by some operators and function calls following another. But on the other hand I’d definitely argue that IDEs at least have a tiny representation of the current source file for navigation or something and that you can click some token and find its uses, definitions, implementations … But it only works if I disable the low power mode. And with my 8Gb RAM MacBook I sometimes have to kill the IDE before running the program to make sure I can still use it at the same time.

                                        1. 7

                                          Maybe if it wasn’t parsing and re-parsing massive amounts of text all the time, it would be more energy efficient…

                                        2. 1

                                          Exactly. And it could extend beyond search; code could be manipulated and organised in more powerful ways. We still have rudimentary support for refactoring in most IDEs, and so we keep going through files and manually making structurally similar changes one by one, for no reason other than the inadequate underlying representation used for code.

                                          I could be wrong and maybe this is impossible to implement in any kind of general way beyond the few specific examples I’ve thought of, but I find it strange that most people dismiss the very possibility of anything better despite the fact that it’s obviously difficult and inconvenient to work with textual source code.

                                          1. 1

                                            The version of cscope that I use does things of that nature. The list of queries it supports:

                                            Find this C symbol:
                                            Find this global definition:
                                            Find functions called by this function:
                                            Find functions calling this function:
                                            Find this text string:
                                            Change this text string:
                                            Find this egrep pattern:
                                            Find this file:
                                            Find files #including this file:
                                            Find assignments to this symbol:
                                            

                                            I use Find functions calling this function a lot, as well as Find assignments to this symbol. You could conceivably add more query types, and I’m certain there are other tools that are less to my admittedly terminal-heavy aesthetic preference that offer more flexible code search and analysis.

                                            The base structure of the software being textual doesn’t get in the way of this at all.

                                            1. 3

                                              Software isn’t textual. We read the text into structures. Our tools should make these structures easier to work with. We need data structures other than text as the common format.

                                              Can I take cscope’s output and filter down to “arguments where the identifiers are of even length”?

                                              1. 5

                                                Compilers and interpreters use structured representations because those representations are more practical for the purposes of compiling and interpreting. It’s not a given that structured data is the most practical form for authoring. It might be. But what the compiler/interpreter does is not evidence of that.

                                                1. 1

                                                  Those representations are more practical for searching and manipulating. Try it!

                                                2. 1

                                                  I would also be interested on your thoughts about Lisp where the code is already structured data. This is an interesting property of Lisp but it does not seem to make it clearly easier to use.

                                                  1. 2

                                                    but it does not seem to make it clearly easier to use.

                                                    Sure it does: makes macros easier to write than a language not designed like that. Once macros are easy, you can extend the language to more easily express yourself. This is seen in the DSL’s of Common LISP, Rebol, and Racket. I also always mention sklogic’s tool since he DSL’s about everything with a LISP underneath for when they don’t work.

                                            2. 2

                                              Sure, but all of these tools (including IDEs) are complicated to implement, error-prone, and extremely underpowered. cscope is just a glorified grep unless I’m missing something (I haven’t used it, just looked it up). The fact that you bring it up as a good example attests to the fact that we’re still stuck somewhere near mid-twentieth century in terms of programming UI.

                                              1. 4

                                                I bring it up as a good example because I use it all the time to great effect while working on large scale software projects. It is relatively simple to understand what it does, it’s been relatively reliable in my experience, and it helps a lot in understanding the code I work on. I’ve also tried exuberant ctags on occasion, and it’s been pretty neat as well.

                                                I don’t feel stuck at all. In fact, I feel wary of people attempting to invalidate positive real world experiences with assertions that merely because something has been around for a long time that it’s not still a useful way to work.

                                          2. 2

                                            Have you noted, that the Luna language has dual representation? Where each visual program has an immediate and easily editable text representation, and the same is true in the other direction as well? This is intended to be able to keep the benefits of the text interface, while adding the benefits of a visual representation! That’s actually the main idea behind Luna.

                                            1. 1

                                              What about the power users who use things like Excel or Salesforce? These are GUIs perfectly tailored to specific tasks. A DJ working with a sound board certainly wouldn’t want a textual interface.

                                              Textual interfaces are bad, but they are generic and easy to write. It’s a lot harder to make an intuitive GUI, let alone one that works on something as complex as a programming language. Idk if Luna is worthwhile, but text isn’t the best user interface possible imho

                                              1. 3

                                                DJs use physical interfaces, and the GUIs emulation of those physical interfaces are basically all terrible.

                                                I’ve never heard of anyone liking Salesforce, I think that must be Stockholm Syndrome. Excel’s primary problem in my opinion is that it has essentially no way of seeing how data is flowing around. If something had the kind of ‘reactive’ nature of Excel while being text-based I’d much prefer that.

                                                Textual interfaces are excellent. While there are tasks that benefit from a GUI - image editing for example - in most cases GUIs are a nicer way of representing things to a new user but are bad for power users. I wouldn’t expect first year computer science students to use vim, as it’s not beginner-friendly, but it’s by far the best text editor out there in the hands of an experienced user.

                                                1. 2

                                                  I wouldn’t expect first year computer science students to use vim, as it’s not beginner-friendly, but it’s by far the best text editor out there in the hands of an experienced user.

                                                  I’d call myself an “experienced user” of vim. I’ve written extensions, given workshops, and even written a language autoindent plugin, which anyone who’s done it knows is like shoving nails through your eyeballs. About once a year I get fed up with the limitations of text-only programming and try to find a good visual IDE, only to switch back when I can’t find any. Just because vim is the best we currently have doesn’t mean it’s actually any good. We deserve better.

                                                  (For the record, vim isn’t beginner-unfriendly because it’s text only. It’s beginner-unfriendly because it’s UI is terrible and inconsistent and the features are all undiscoverable.)

                                                  1. 2

                                                    Most people don’t bother to learn vimscript properly, treating it much like people treated Javascript for years: a bunch of disparate bits they’ve picked up over time, with no unifying core. But once you actually learn it, it becomes much easier to use and more consistent. The difference between expressions and commands becomes sensible instead of seeming like an inconsistency.

                                                    I never get fed up with the limitations of text-only programming, because I don’t think they exist. Could you elaborate on what you are saying those limitations are?

                                                    And I totally, 100% disagree with any claim that vim’s UI is bad or inconsistent. On the contrary, it’s extremely consistent. It’s not a bunch of little individual inconsistent commands, it’s motions and text objects and such. It has extensive and well-written help. Compared to any other IDE I’ve used (a lot), it’s way more consistent. Every time I use a Mac program I’m surprised at how ad-hoc the random combinations of letters for shortcuts are. And everything requires modifier keys, which are written with ridiculous indecipherable symbols instead of ‘Ctrl’ ‘Shift’ ‘Alt’ etc. Given that Mac is generally considered to be very easy to use, I don’t think typical general consensus on ease of use is very instructive.

                                            2. 3

                                              Bret Victor explains the persistence of textual languages as resistance to change, drawing an equivalence between users of textual languages now and assembly programmers who scoffed at the first higher-level programming languages. But this thread is evidence that at least some people are interested in using a language that isn’t text-based. Not everyone is fairly characterized by Bret Victor’s generalization. So then why hasn’t that alternative emerged? There are plenty of niche languages that address a minority preference with reasonable rates of adoption. With the exception of Hypercard, I can’t think of viable graphical programming language. Even Realtalk, the language that runs Dynamicland (Bret Victor’s current focus), is text-based, being a superset of Lua. I keep hearing about how text-based languages are old-fashioned and should die out, but I never hear anything insightful about why this hasn’t happened naturally. I’m not denying that there are opportunities for big innovation but “make a visual programming language” seems like an increasingly naive or simplistic approach.

                                              1. 4

                                                I think it has to do with the malleability of text. There’s a basic set of symbols and one way to arrange them (sequentially.) Almost any problem can be encoded that way. Emacs’ excellent org-mode is a testament to the virtue of malleability.

                                                Excel also has that characteristic. Many, many kind of problems can be encoded in rectangles of text with formulas. (Though I might note that having more ways to arrange things allows new kinds of errors, as evidenced by the growing cluster of Excel features for tracing dependencies & finding errors.)

                                                Graphical languages are way less malleable. The language creator decides what elements, relations, and constraints are allowed. None of them let me redefine what a rectangle represents, or what relations are allowed between them. I think that’s why these languages can be great at solving one class of problem, but a different class of problem seems to require a totally different graphical language.

                                                1. 1

                                                  My suspicion is that it’s because graphical languages merge functionality and aesthetics, meaning you have to think very, VERY hard about UI/UX and graphic design. You need to be doing that from the start to have a hope of it working out.

                                              1. 13

                                                How to Solve It - G. Polya.

                                                1. 6

                                                  The only thing I ever remember about that book is, paraphrased, if there’s a problem you can’t solve, there’s also a smaller problem you can’t solve. Find that smaller problem and solve it first.

                                                  1. 2

                                                    Sounds like a good summary, but for much broader meaning of the word “problem” that would seem from it. The book gives a list of questions designed to explore the space around your problem from many different perspectives, hopefully guiding you towards a different problem that’s easier to solve, and will contribute necessary insight or data into your main one.

                                                    1. 1

                                                      The idea is called divide and conquer.

                                                      1. 3

                                                        Divide and conquer is a specific instance of that tactic. It’s one where solving the smaller problem actually gives you part of the solution of the larger problem. But in mathematics you often solve a truly simpler version of a problem to discover a strategy to attack the larger problem. The solution to the simpler problem itself is not used any more.

                                                  1. 2

                                                    The comments in the post discuss a 5XX vs a 4XX error and that client-side errors should be fixed by the client. Now I am wondering if the GDPR applies to European citizens or people that are currently in Europe (maybe a day trip or what ever). I usually thought that these GDPR filters are using geoIp. But what if a European citizen is in the US and the other way around? I only checked Wikipedia for this and they say the GDPR applies to EU-citizens. So how to figure out if a web client is a EU-citizen? What am I doing wrong?

                                                    1. 4

                                                      The companies are just trying to protect themselves as best they can. Realistically, a European citizen suing a US-only company in a European court over European law is being frivolous and the company will likely not be affected in any way, so the butt-covering of geoip blocking is more a political statement to potential sue-ers than it is actual legal protection.

                                                      1. 6

                                                        What is the actual message to European users of such political statement?

                                                        We don’t want your money? We don’t want your data? You do not deserve our technology? We are the Spiders of the Web and you are just a fly?

                                                        Btw, as an European I would really appreciate a clear statement on a website saying “we are sorry but we cannot protect your data and respect your rights, please search for one of our competitor that can do it better”.

                                                        I’m not ironic.
                                                        GDPR defines several important rights for the data subject that imply certain investments in cybersecurity and a basic quality of service. Being able to say “I cannot do this right, please ask to someone else” is a sign of professionalism.

                                                      2. 3

                                                        You figure it out by asking them. There are many sites that don’t serve US citizens for various reasons. When you enter them, they ask you to declare you are not a US citizen. It’s as simple as that. If they lie, it’s on them.

                                                        Honestly, this GDPR thing has gotten many Americans acting indignated and generally quite irrational over something that hardly changes anything and is not without a slew of precedent. It’s just the first time US companies are visibly seriously affected by law elsewhere. Now you know how it feels. Get over the feeling and deal with it.

                                                        1. 1

                                                          Well, in principle, I would guess that European courts might be apprehensive about dictating law globally, which would essentially be the case if it was found that GDPR applies to European citizens wherever they may be, and even if a website operator had taken all reasonable precautions to block European citizens from using their cite.

                                                          1. 3

                                                            GDPR apply to data of European citizens worldwide and to data of non European citizens collected while they are in the Union.

                                                            However, if your registration form have a mandatory checkbox “I’m NOT a European citizen and I’m not going to use your services while in the European Union” AND the such checkbox is uncheked by default AND you block all European IPs, I think no European court will ever annoy you.

                                                        1. 24

                                                          As I read this I thought about my experiences with Diaspora and Mastodon. Pages like this one or this one (click “Get Started”, I couldn’t do a deep link because JavaScript) are, IMHO, a big part of the reason these services don’t take off. How can an average user be expected to choose from a basically random list of nodes? How can I, a reasonably “technical” person, even be expected to do so?

                                                          So then why not host my own node? First, I don’t have time and most people I know don’t either. If I was 15 again I totally would because I had nothing better to do. I also don’t want to play tech support for a good chunk of my social network, and providing a service to someone has a tendency to make them view you as the tech support.

                                                          Second, if I do that I’m now in charge of security for my data. As terrible as Twitter and Facebook are, they’re probably still a lot better at securing my data than I am (at the very least they probably patch their systems more often than I would). Even worse, if some non-technical person decides to bite the bullet and create a node for his/her friends, how secure do you think that’s going to be?

                                                          Further, what are the odds that I, or whoever is maintaining the node, basically gets bored of it one day and kills the whole thing? Pretty damn high (maybe I and all my friends are assholes, though, so whatever).

                                                          Anyway, this post really spoke to me because I’ve been trying to escape Evil companies for awhile now and “federated” just doesn’t seem to be the answer. I now believe that centralized is here to stay, but that we should start looking at the organizations that control the data instead of the technology. For example, if Facebook were an open non-profit with a charter that legally prevented certain kinds of data “sharing” and “harvesting” maybe I wouldn’t have any problem with it.

                                                          1. 18

                                                            How can an average user be expected to choose from a basically random list of nodes?

                                                            How did they choose their email provider? Not be carefully weighing the technical options, surely. They chose whatever their friends or parents used, because with working federation it doesn’t matter.

                                                            what are the odds that I, or whoever is maintaining the node, basically gets bored of it one day and kills the whole thing?

                                                            Same as what happened with many early email providers: when they died, people switched to different ones and told their friends their new addresses.

                                                            Really, all this argument of “what if federation isn’t a holy grail” is pointless because we all already use a federated system — email — and we know for a fact that it works for humans, despite all its flaws.

                                                            1. 8

                                                              How did they choose their email provider? Not be carefully weighing the technical options, surely. They chose whatever their friends or parents used, because with working federation it doesn’t matter.

                                                              In contrast to mastodon instances - which are very alike - email providers have differentiated on the interface and guarantees they provide and market that. People react to that.

                                                              1. 2

                                                                In contrast to mastodon instances

                                                                While this was largely true in the beginning, many Fediverse nodes now do market themselves based on default interface, additional features (e.g. running the GlitchSoc fork or something like it), or even using non-Mastodon software like Pleroma. I suspect this will only increase as additional implementations (Rustodon) and forks (#ForkTogether) take off and proliferate.

                                                              2. 8

                                                                How did they choose their email provider?

                                                                I think federated apps like Mastodon are fundamentally different than email providers. Most email providers are sustainable businesses, they earn money with adds or paid plans or whatever and have their own emails servers and clients with specific features. Self-hosted email servers are a minority. Please tell if I wrong, but I don’t think one can easily earn money with a Mastodon instance.

                                                                However I agree that both are federated.

                                                                1. 1

                                                                  i don’t know if any nodes do this but you could charge for mastodon hosting

                                                                2. 6

                                                                  You’re certainly not wrong, though I would argue that email, particularly as it was 20+ years ago when it went “mainstream”, is much simpler (for instance, it doesn’t require any long-term persistence or complicated access control) and therefore easier to federate successfully (in a way that humans can handle) than social networking.

                                                                  1. 1

                                                                    AP style social network federation also doesn’t require long-term persistence or complicated access control.

                                                                    1. 1

                                                                      email is social networking. are there particular social networking features you had in mind?

                                                                      1. 3

                                                                        Yeah, I listed them in my comment… “long-term persistence or complicated access control”. Admittedly I didn’t go into much detail. Email is a very simple social network, there isn’t much “meat” to it, particularly as it existed when it became popular.

                                                                        1. 1

                                                                          email has very long term persistence, much longer than something like facebook because it’s much easier to make backups of your emails than to make backups of your facebook interactions.

                                                                          i guess i don’t know what you mean by “complicated access control.”

                                                                          1. 1

                                                                            Email is basically fire and forget. You download it to your computer and then you’ve got it forever (modern email does more, but also includes more of the privacy / data issues that come with other social networks). But most users can’t easily give other people on-demand access to their emails, which is the case with Facebook, Twitter, etc. Email is really meant for private communication (possibly with a large group, but still private), Facebook and company are for private, semi-private, and even public communication, and they require a user to be able to easily retroactively grant or retract permissions. Email doesn’t handle these other use-cases (this isn’t a fault of email, it doesn’t try to).

                                                                        2. 2

                                                                          The ability for interested parties to interact without reply all. I can post a picture of a beautiful burrito, and people can comment or ignore at their leisure, and then reply to each other. I guess there’s some preposterous email solution where I mail out a link to an ad hoc mailing list with every update and various parties subscribe, but… meh.

                                                                          1. 2

                                                                            something that handles a feature like that need not be email per se, but it could have a very similar design, or be built on top of email. something like what you suggested wouldn’t seem preposterous if the clients were set up to facilitate that kind of use.

                                                                      2. 3

                                                                        In the case of Mastodon, which instance you pick does matter. Users can make posts that are only visible to others in the same instance. If you pick the “wrong” home instance, you’ll have to make another account in another instance to see the instance-private posts there. If you’re a new Mastodon user, you might not know that one instance is good for artists and another good for musicians, etc. In any case, this is as easily solvable problem by adding descriptions and user-provided reviews to each instance.

                                                                      3. 2

                                                                        These ‘which instance to join’ sites are completely useless, I wish they wouldn’t exist at all.

                                                                        1. 1

                                                                          Second, if I do that I’m now in charge of security for my data. As terrible as Twitter and Facebook are, they’re probably still a lot better at securing my data than I am

                                                                          Setting a price tag on your datas doesn’t secure them. There are enough scams and hoaxes on Facebook to share your information with other companies that I have to disagree with you. And since those social networks are collecing more data than necessary, it is easier to lose data.

                                                                          1. 2

                                                                            Facebook and Twitter also present single valuable targets and are thus more likely to be targeted. A hundred mastodon instances may be individually less secure due to the operators having fewer resources or less experience, but compromising a single server won’t get you as much.

                                                                            1. 2

                                                                              That’s a good point, although Wordpress vulnerabilities are still a big deal even though there are tons of small servers. The server might not be a monolith, but if the software is then it’s only slightly more work to attack N instances.

                                                                              1. 1

                                                                                True, although it depends whether the vulnerabilities are in the application being served or in the web server or OS serving it.

                                                                        1. 7

                                                                          This is a great usability improvement. Thank you Peter Hessler :)

                                                                          That said, it’s still a little bit sad that this is only just being introduced in 2018.

                                                                          1. 34

                                                                            That said, it’s still a little bit sad that this is only just being introduced in 2018.

                                                                            Technically - OpenBSD has had various toolings (1, 2, 3 and others) to do this very task for quite a long time. But none of them were considered the correct approach.

                                                                            Also, this is something that’s pretty unique to OpenBSD IMO. The end result is the same as with other systems.. sure. But this is unique among the unix world.

                                                                            Q: What’s the difference?

                                                                            Glad I asked! This is entirely contained within the base system and requires no tools beyond ifconfig!

                                                                            Linux has ip, iw, networkmanager, iwconfig..(likely others)… and they are all using some weird combo of wpa_supplicant.. autogen’d text files.. and likely other things.

                                                                            Have you ever tried to manually configure wireless on linux? It’s a nightmare. Always has been.

                                                                            NetworkManager does a really good job of making it feel like there isn’t a kludge going on behind the scenes.. It does this by gluing all the various tools together so you don’t have to know about them. IMO this is what happens when you “get it done now” vs “do it right”.

                                                                            With great simplicity comes great security:

                                                                            NetworkManager@6c3174f6e0cdb3e0c61ab07eb244c1a6e033ff6e:

                                                                            github.com/AlDanial/cloc v 1.74  T=28.62 s (48.2 files/s, 45506.1 lines/s)
                                                                            --------------------------------------------------------------------------------
                                                                            Language                      files          blank        comment           code
                                                                            --------------------------------------------------------------------------------
                                                                            PO File                          66         125328         161976         457879
                                                                            C                               541          71112          66531         321839
                                                                            C/C++ Header                    528          10430          15928          34422
                                                                            XML                              59           1406           2307           6692
                                                                            make                              6            885            229           5009
                                                                            Python                           40           1189           1128           4597
                                                                            NAnt script                      65            626              0           3968
                                                                            m4                                8            237            123           1958
                                                                            Lua                              11            212            453           1314
                                                                            Bourne Shell                     21            232            238           1115
                                                                            XSLT                              5             65              3            929
                                                                            Perl                              4            166            243            480
                                                                            Bourne Again Shell               11             30             35            241
                                                                            C++                               4             62            121            178
                                                                            YAML                              4             12              6            161
                                                                            JavaScript                        1             33             21            130
                                                                            Ruby                              3             39             92            110
                                                                            Lisp                              2             15             24             23
                                                                            --------------------------------------------------------------------------------
                                                                            SUM:                           1379         212079         249458         841045
                                                                            --------------------------------------------------------------------------------
                                                                            

                                                                            VS

                                                                            ifconfig@1.368:

                                                                            github.com/AlDanial/cloc v 1.74  T=0.12 s (32.2 files/s, 58201.7 lines/s)
                                                                            -------------------------------------------------------------------------------
                                                                            Language                     files          blank        comment           code
                                                                            -------------------------------------------------------------------------------
                                                                            C                                2           1009            345           5784
                                                                            C/C++ Header                     1              7             16             58
                                                                            make                             1              3              1              6
                                                                            -------------------------------------------------------------------------------
                                                                            SUM:                             4           1019            362           5848
                                                                            -------------------------------------------------------------------------------
                                                                            

                                                                            Anyway - I guess my point is this:

                                                                            • Almost every OS achieves this goal.. sure.
                                                                            • Most have had this feature for quite some time.. agree (Including OpenBSD!).
                                                                            • None of them have it implemented as simply and well-thought-out as OpenBSD.
                                                                            1. 5

                                                                              Have you ever tried to manually configure wireless on linux? It’s a nightmare. Always has been.

                                                                              No. The Linux’s I use come with an out-of-the-box experience that makes wireless as easy as clicking a box, clicking a name, typing in the password, it works, and it reconnects when nearby. They have been like that since I bought an Ubuntu-specific Dell a long time ago. They knew it was a critical feature that needed to work easily with no effort with some doing that upon installation so parts of the install could be downloaded over WiFi. Then, they did whatever they had to do in their constraints (time/talent/available code) to get it done.

                                                                              And then I was able to use it with only breaks being wireless driver issues that had answers on Q&A sites. Although that was annoying, I didn’t have to think about something critical I shouldn’t have to think about. Great product development in action for an audience that has other things to do than screw around with half-built wireless services. That’s a complement about what I used rather than a jab at OpenBSD’s which I didn’t use. I’m merely saying quite a few of us appreciate stuff that saves us time once or many times. If common and critical, adoption can go up if it’s a solved problem with minimal intervention out of the box.

                                                                              That said, props to your project member who solved the problem with a minimally-complex solution in terms of code and dependencies. I’m sure that was hard work. I also appreciate you illustrating that for us with your comparisons. The difference is almost comical in the work people put in with very different talents, goals and constraints. And m4 isn’t gone yet. (sighs)

                                                                              1. 7

                                                                                No. The Linux’s I use come with an out-of-the-box experience that makes wireless as easy as clicking a box, clicking a name, typing in the password, it works, and it reconnects when nearby.

                                                                                And then something goes wrong in the fragile mess of misfeatures, and someone has to dig in and debug, or a new feature comes along and someone has to understand the stack of hacks to understand it, before it can be added. There’s something to be said for a system that can be understood.

                                                                                1. 4

                                                                                  There is something to be said for a system to be understood. I totally agree. I also think there’s something to be said for a reliable, more-secure system that can be effortlessly used by hundreds of millions of people. A slice of them will probably do things that were worth the effort. The utilitarian in me says make it easy for them to get connected. The pragmatist also says highly-usable, effortless experience leads to more benefits in terms of contributions, donations, and/or business models. These seemingly-contradicting philosophies overlap in this case. I think end justifies the means here. One can always refactor the cruddy code later if it’s just one component in the system with a decent API.

                                                                                  1. 3

                                                                                    One can always refactor the cruddy code later if it’s just one component in the system with a decent API.

                                                                                    The problem isn’t the code, it’s the system that it’s participating in.

                                                                                    1. 2

                                                                                      One can always refactor the cruddy code later if it’s just one component in the system with a decent API.

                                                                                      This just leads to systemd, and more misfeatures…

                                                                                      1. 3

                                                                                        There’s Linux’s without systemd. Even those that had it didn’t before they got massive adoption/impact/money. So, it doesn’t naturally lead to it. Just bad, decision-making in groups controlling popular OS’s from what I can tell. Then, there’s also all the good stuff that comes with their philosophy that strict OS’s like OpenBSD haven’t achieved. The Linux server market, cloud, desktops, embedded, and Android are worth the drawbacks if assessing by benefits gained by many parties.

                                                                                        Personally, I’m fine with multiple types of OS being around. I like and promote both. As usual, I’m just gonna call out anyone saying nobody can critique an option or someone else saying it’s inherently better than all alternatives. Those positions are BS. Things things are highly contextual.

                                                                                2. 1

                                                                                  This is really great. I wish all other projects can do that, preferring elegancy to throwing code on the wall, but sometimes life really takes its toll and we cave and just make Frankenstein to get shit done.

                                                                                  I really appreciate all the works by OpenBSD folks. Do you have any idea how other *BSD’s deal with the wireless?

                                                                                  1. 1

                                                                                    Do you have any idea how other *BSD’s deal with the wireless?

                                                                                    I don’t - sorry :D

                                                                                3. 3

                                                                                  Whats really sad is that the security of other operating systems can’t keep up despite having more man power.

                                                                                  1. 2

                                                                                    It’s almost like if you prioritize the stuff that truly matters, and be willing to accept a little bit of UX inconvenience, you might happen upon a formula that produces reliable software? Who would have thought?

                                                                                    1. 2

                                                                                      That’s what I told OpenBSD people. They kept on a poorly-marketed monolith in unsafe language without the methods from CompSci that were knocking out whole classes of errors. They kept having preventable bugs and adoption blockers. Apparently, the other OS developers have similarly, hard-to-change habits and preferences with less focus on predictable, well-documented, robust behavior.

                                                                                    2. 1

                                                                                      I think this is just a matter of what you think matters. There’s no sadness here. The ability to trade off security for features and vice versa is good. It lets us accept the level of risk we like.

                                                                                      On the other hand, it’s really sad, for instance, that OpenBSD has had so many public security flaws compared to my kernel ;P

                                                                                      1. 1

                                                                                        On the other hand, it’s really sad, for instance, that OpenBSD has had so many public security flaws compared to my kernel ;P

                                                                                        What’s your kernel?

                                                                                        1. 2

                                                                                          It’s a joke. Mine is a null kernel. It has zero code, so no features, so no security flaws. Just like OpenBSD has fewer features and fewer known security flaws than Linux, mine has fewer features but no security flaws.

                                                                                          Unlike OpenBSD, mine is actually immune to Meltdown and Spectre.

                                                                                          1. 1

                                                                                            Not having public flaws doesn’t mean you don’t have flaws. Could mean not enough people are even considering checking for flaws. ;)

                                                                                            1. 1

                                                                                              Oh OK lol.

                                                                                      2. 0

                                                                                        That said, it’s still a little bit sad that this is only just being introduced in 2018.

                                                                                        Would you like to clarify what you mean by this comment? Cause right now my interpretation of it is that you feel entitled to have complicated features supported in operating systems developed by (largely unpaid) volunteers.

                                                                                        1. 11

                                                                                          I’m getting a bit tired of every complaint and remark being reduced to entitlement. Yes, I know that there is a lot of unjustified entitlement in the world, and it is rampant in the open source world, but I don’t feel entitled to anything in free or open source software space. As someone trying to write software in my spare time, I understand how hard it is to find spare time for any non-trivial task when it’s not your job.

                                                                                          Though I am not a heavy user, I think OpenBSD is an impressive piece of software, with a lot of thought and effort put into the design and robustness of the implementation.

                                                                                          I just think it’s somewhat disheartening that something this common (switching wireless networks) was not possible without manual action (rewriting a configuration file, or swapping configuration files, and restarting the network interface) every time you needed to switch or moved from home to the office.

                                                                                          Whether you feel like this is me lamenting the fact that there are so few contributors to important open source projects, me lamenting the fact that it is so hard to make time to work on said project, or me being an entitled prick asking for features on software I don’t pay for (in money or in time/effort) is entirely your business.

                                                                                          1. 5

                                                                                            Just for the record I didn’t think you sounded entitled. The rest of the comment thread got weirdly sanctimonious for some reason.

                                                                                            Volunteers can work on whatever they want, and anybody’s free to comment on their work. Other operating systems have had the ability to switch wifi networks now for a long time, so it’s fair to call that out. And then Peter went and did something about it which is great.

                                                                                            Previously I’ve been using http://ports.su/net/wireless for wifi switching on my obsd laptop, but will use the new built-in feature when I upgrade the machine.

                                                                                            Some of the delay for the feature may be because the OS, while very capable, doesn’t seem designed to preemptively do things on the user’s behalf. Rather the idea seems to be that the user knows what’s best and will ask the OS to do things. For instance when I dock or undock my machine from an external monitor it won’t automatically switch to using the display. I have a set of dock/undock scripts for that. I appreciate the simple “manual transmission” design of the whole thing. The new wifi feature seems to be in a similar spirit, where you rank each network’s desirability and the OS tries in that order.

                                                                                            1. 2

                                                                                              Interesting, I didn’t know about that to. I used my own bash script to juggle config files and restart the interface, but the new support in ifconfig itself is much easier.

                                                                                              I think the desire for OpenBSD to not do things without explicit user intent are certainly part of why this wasn’t added before, as well as limited use as a laptop OS until relatively recently.

                                                                                            2. 2

                                                                                              Thanks for taking the time to respond.

                                                                                              To be clear, I don’t believe you’re some sort of entitled prick – I don’t even know you. But, I do care that people aren’t berating developers with: “That’s great, but ____” comments. Let’s support each other, instead of feigning gratitude. It wasn’t clear if that’s what you were doing, hence, my request for clarification.

                                                                                              That being said, my comment was poorly worded, and implied a belief that you were on the wrong side of that. That was unfair, and I apologize.

                                                                                              I just think it’s somewhat disheartening that something this common (switching wireless networks) was not possible without manual action (rewriting a configuration file, or swapping configuration files, and restarting the network interface) every time you needed to switch or moved from home to the office.

                                                                                              Well, I’m just not going to touch this…. :eyeroll:

                                                                                              1. 1

                                                                                                I apologize if my response was a little bit snide. I’ve been reading a lot of online commentary that chunks pretty much everything into whatever people perceive as wrong with society (most commonly: racism, sexism, or millenial entitlement - I know these are real and important issues, but not everything needs to be about them). I read your remark in the context and may have been a little harsh.

                                                                                                Regarding the last segment - how WiFi switching worked before - there may have been better ways to do this, but I’m not sure they were part of the default install. When I needed this functionality on OpenBSD, I basically wrote a bash script to do these steps for me on demand, and that worked alright for me. It may not have been the best way, so my view of the OpenBSD WiFi laptop landscape prior to the work of Peter may not be entirely appropriate or accurate.

                                                                                              2. 1

                                                                                                I just think it’s somewhat disheartening that something this common (switching wireless networks) was not possible without manual action (rewriting a configuration file, or swapping configuration files, and restarting the network interface) every time you needed to switch or moved from home to the office.

                                                                                                I’m more blunt here that leaving that to be true in a world with ubiquitous WiFi was a bad idea if they wanted more adoption and donations from market segment that wanted good, out-of-the-box support for WiFi. If they didn’t want that, then it might have been a good choice to ignore it for so long to focus on other things. It all depends on what their goals were. Since we don’t know them, I’ll at least say that it was bad, neutral, or good depending on certain conditions like with anything else. The core userbase was probably OK with whatever they had, though.

                                                                                              3. 3

                                                                                                First, both free speech and hacker culture say that person can gripe about what they want. They’re sharing ideas online that someone might agree with or act on. We have a diverse audience, too.

                                                                                                Second, the project itself has developers that write cocky stuff about their system, mock the other systems, talk that one time about how they expect more people to be paying them with donations, more recently talk about doing things like a hypervisor for adoption, and so on. Any group doing any of that deserves no exception to criticism or mockery by users or potential users. It’s why I slammed them hard in critiques, only toning it down for the nice ones I met. People liking critiques of other projects or wanting adoption/donations should definitely see others’ critiques of their projects, esp if its adoption/donation blockers. I mean, Mac’s had a seemless experience called Rendevous or something in 2002. If I’m reading the thread right, that was 16 years before OpenBSD something similar they wanted to make official. That OpenBSD members are always bragging when they’re ahead of other OS’s on something is why I’m mentioning it. Equal treatment isn’t always nice.

                                                                                                “But, I do care that people aren’t berating developers with: “That’s great, but ____” comments. Let’s support each other, instead of feigning gratitude. It wasn’t clear if that’s what you were doing, hence, my request for clarification.”

                                                                                                I did want to point out that we’ve had a lots of OpenBSD-related submissions and comments with snarky remarks about what other developers or projects were doing. I at least don’t recall you trying to shut them down with counterpoints assessing their civility or positivity toward other projects (say NetBSD or Linux). Seems a little inconsistent. My memory is broken, though. So, are you going to be countering every negative remark OpenBSD developers or supporters make about projects with different goals telling them to be positive and supportive only? A general rule of yours? Or are you giving them a pass for some reason but applying the rule to critics of OpenBSD choices?

                                                                                                1. 1

                                                                                                  I at least don’t recall you trying to shut them down with counterpoints assessing their civility or positivity toward other projects (say NetBSD or Linux). Seems a little inconsistent.

                                                                                                  I’m not the Internet Comment Police, but you seem to think you are for some reason… Consider this particular instance “me griping about what I want.”

                                                                                                  Or are you giving them a pass for some reason but applying the rule to critics of OpenBSD choices?

                                                                                                  This wasn’t about OpenBSD at all. This started out as a request for clarification on the intent of an ambiguous comment that seemed entitled. There seems to be a lot of that happening today, and a lot of people defending it for whatever reason, which is even worse.

                                                                                                  1. 1

                                                                                                    I’m not the Internet Comment Police

                                                                                                    Your comments came off that way to me between the original and follow-ups. Far as not about OpenBSD, it’s in a thread on it with someone griping it lacked something they wanted. The OpenBSD members griping about third party projects not having something they wanted to see more of typically got no comment from you. The inconsistency remains. I’m writing it off as you’re just a fan of their style of thinking on code, quality, or something.

                                                                                                2. 2

                                                                                                  i think he’s sad that there haven’t been enough volunteers to make it happen sooner

                                                                                                  1. 2

                                                                                                    That’s certainly one possibility, but not how I took it initially, and why I asked for clarification. I’ve seen too many people over the years attempt to disguise their entitlement by saying “thanks.”

                                                                                                    I’d have liked to see this comment worded as:

                                                                                                    This is a great usability improvement. Thank you Peter Hessler :) It’s a shame that there isn’t a better way to bring these important usability features to OpenBSD faster. What is the best way to help make that happen? Donations to the OpenBSD Foundation? Sponsor the work directly? Something else?

                                                                                                    Now, it’s also possible that the OP has ties to OpenBSD, and the comment was self-deprecating. But, one can’t infer that from the information we see without investigating who the OP is, and their affiliations…

                                                                                                    1. 0

                                                                                                      one can’t infer anything beyond what they said

                                                                                                      1. 2

                                                                                                        I’m not sure you understand what infer means. One certainly can infer meaning from a comment, based on previous actions, comments, etc..

                                                                                                        My point remains: It’d be nice if the OP would clarify what they mean. My interpretation of the OP’s comment is just as likely as your interpretation. My interpretation is damaging to the morale of existing volunteer contributors to FOSS, and gives potential contributors to FOSS reasons to not contribute all together. I don’t know about you, but I want to encourage people to contribute to FOSS, as doing so moves us closer to a free and open society. And, that alone, is the reason I’m even bothering to continue responding to this thread…

                                                                                                        1. 1

                                                                                                          he said “it’s sad.” that’s all we know. the leap is that this means “entitlement.”

                                                                                                          1. 1

                                                                                                            “It’s pretty sad that it took someone else so long to prioritize work I think is necessary.”

                                                                                                            I think it’s pretty easy to take what was written and read it this way. But maybe my glass is half empty today.

                                                                                                          2. 0

                                                                                                            One can infer based on a comment, but the inference will most likely be dimwitted bullshit.

                                                                                                            Without the magic trifecta of body language, vocal intonation, and facial expression us monkeys are just shit at picking up on any extra meaning. So take the comment at face value.

                                                                                                            It expresses gratitude, it focuses on a specific recipient, and it lauds the feature. After, it regrets that it couldn’t/didn’t happen earlier.

                                                                                                            There’s no hidden meaning here, and if the commenter intended a hidden meaning he’s a dufus too, because there’s no unicode character for those. U+F089A6CDCE ZERO WIDTH SARCASTIC FUCK YOU MARK notwithstanding.

                                                                                                            At some point we all need to stop insisting that we have near-telepathic powers, especially outside of meatspace.

                                                                                                            1. 2

                                                                                                              So, what you’re saying is that I can write anything I want, and since you can’t see or hear other clues, there’s no way you can downvote (in good faith) this comment as trolling?

                                                                                                              Not sure text works that way…

                                                                                                      2. 1

                                                                                                        They had the solution to do it all the time, but it wasn’t invented here, so it’s bad.

                                                                                                  1. 4

                                                                                                    However, iBoot is closed source, but

                                                                                                    … wasn’t the source leaked too?

                                                                                                    1. 6

                                                                                                      Yea it was, seems apple got it removed however ( https://github.com/github/dmca/blob/master/2018/2018-02-07-Apple.md )

                                                                                                      However this might be the real thing, https://github.com/ShapManasick/iBoot - if not I know I cloned it to a private server somewhere :)

                                                                                                    1. 1

                                                                                                      Email lost it’s status to the web, but Zawinski’s law fits here (again):

                                                                                                      Every program attempts to expand until it can read mail. Those programs which cannot so expand are replaced by ones which can.

                                                                                                      I appreciate this feature a tho.

                                                                                                      1. 1

                                                                                                        There is a YouTube channel called Bosnianbill that is also testing smart locks sometimes. He is not looking at the IoT side of such locks but it’s still interesting to watch him take apart these locks. Master Lock: https://youtu.be/YsKMsvx8vvo Noke: https://youtu.be/PqeWupKN2W0

                                                                                                        1. 20

                                                                                                          Having got one business prediction right, I will stick my neck out and make another one (plus the obvious one that the world will not end because of this purchase).

                                                                                                          1. -3

                                                                                                            Since we are doing wild predictions … Here is one, I’ll stick a neck out on … You’re probably young, early in your career, say <5 experience in the industry. Certainly not in the industry since the 90’s early 2000s. It’s fine, there is nothing I can say on this topic that will change anything whatsoever. But save this thread. Queue it up for the day after your 30 B-day or say in 7 years. You’ll be amused between what the you of today believe and what the you of tomorrow will have learned in this industry and specifically about this purchase.

                                                                                                            1. 23

                                                                                                              Checking that one is too easy after he linked to a blog with posts dating back 10 years. And checking out posts from 2008… There it says having not taught programming for 25 years.

                                                                                                              1. 20

                                                                                                                IIRC @derek-jones was on the C99 standardization committee.

                                                                                                                1. 3

                                                                                                                  The beauty of predictions is there capability of being wrong. I was wrong, surprised to be so, but wrong.
                                                                                                                  However, another prediction is still undecided, the impact of MS buying Github and how they will manipulate their influence over it compared to the counterfactual. I’m seriously not a tin foil hat kinda guy, but MS is just never a good thing when then step into any area whether the Internet, Browers, Software Development, OS’s, you name it. It is always a net-net-negative (not from a business standpoint of course) but from an overall “good” in that respective area. Far more harm than good will result.

                                                                                                                  1. 5

                                                                                                                    I still don’t get your reply to Derek. He never claimed that MS purchases are good for the community. In fact, he is predicting an EDG buyout solely because he thinks it will allow for vendor lock-in.

                                                                                                                    1. 4

                                                                                                                      I believe Derek triggered him with the line

                                                                                                                      (plus the obvious one that the world will not end because of this purchase)

                                                                                                                      Where he propably refers to his experience from earlier (pre-git, pre-internet) times and how there will be other ways for open source and development (back to Mailing lists, Gitlab, …).

                                                                                                                      But Grey, when hearing about GitHub not being changed too much (as Derek also stated in his posting, “sluggish Integration”, but also “more data friendly”), remembered history on Microsoft (they were anti-open-source and are working a lot on changing their image). GitHub being an “open-source community” therefore is in danger getting swallowed by this “anti-open-source business”.

                                                                                                                      And I can understand getting emotional about such things. And emotion kills rationality. Which propably led to this misunderstanding.

                                                                                                              1. 1

                                                                                                                Thank you so much! This video and the sources in it is exactly what I need to start understanding this.

                                                                                                              1. 5

                                                                                                                Continuing my bachelor thesis. The verification tool has problems with simplifying conditionals expressions when the head is a constant expression (from macros for example). I spent too much time for that on the weekend already (recursively checking a syntaxtree and converting it into a CFA while doing optimizations wouldn’t go in my head). I hope to finish it today and then start verifying some IP input queuing. For that I have to see how to do the initialization the kernel usually would do during boot.

                                                                                                                1. 2

                                                                                                                  Now I can read the same article multiple times with the word order changed. I am glad I am avoiding all this as much as I can.

                                                                                                                  1. 2

                                                                                                                    Still working on my bachelor thesis. The title is Application of Formal Methos to OpenBSD Network Modules. Bluhm and a PhD Student called Thomas from SoSy-Lab at LMU are helping me.

                                                                                                                    Last week I was busy preprocessing networking C code so the verification tool (CPAchecker) could understand it. Problems arised: kernel memory management, machine dependent code, where to start, where to stop, what to ignore. Bluhm suggested starting with the IP input queue. I ended the week with reading ip_input.c. Turns out there is already a repo with preprocessed files of src. (Thanks Bluhm and Zaur)

                                                                                                                    This week I will need to think about what to stub, where to stop and what to do about ip_init.

                                                                                                                    1. 2

                                                                                                                      Implementing things for my thesis. Still not sure what the outcome will be. But I am happy to have interesting things to do.

                                                                                                                      1. 2

                                                                                                                        Starting my bachelor thesis. First week: Organisation, Literature and Basics.