1. 7

    One thing I would love to read more about is how to determine the cutoff between scaling horizontally and investing time/money in optimizing your software.

    1. 2

      Oooo, that’s a good one. I have a couple hand-wavey heuristics. I’ll think more about trying to turn that into something more real.

      I have the next 2-3 posts vaguely planned out. But, I’ll definitely be thinking about your idea @hwayne.

      1. 1

        Doesn’t it boil down to, basically, “it’s a knack, spend 10 years doing it and you’ll get good at judgment”?

        1. 2

          I’d definitely take a more “business” driven approach to that problem. Optimizing your software for cost should only be done if the money it saves is superior to what it costs to optimize it.

          You also have to take into account indirect costs like when using weird optimization tricks can make code less readable sometimes and also has a cost for future development.

          1. 1

            On the other hand, scaling horizontally adds costs of coordinating multiple servers, which includes load balancing, orchestrating deployments, distributed system problems, etc.

            1. 1

              The business-driven approach is not always the best for society as a whole. It doesn’t take into account negative externalities like the environmental cost of running inefficient programs and runtimes.

            2. 2

              I had a few that helped a lot:

              1. Use the fastest components. Ex: Youtube used lighttpd over Apache.

              2. If caching can help, use it. Try different caching strategies.

              3. If it’s managed, use a system language and/or alternative GC.

              4. If fast path is small, write the data-heavy part in an optimizable language using best algorithms for that. Make sure it’s cache and HD-layout friendly. Recent D submission is good example.

              5. If it’s parallelizable, rewrite the fast path in a parallel, programming language or using such a library. Previously, there was PVM, MPI, Cilk, and Chapel. The last one is designed for scale-up, scale-out, and easy expression simultaneously. Also, always use a simpler, lighter solution like that instead of something like Hadoop or SPARK if possible.

              6. Whole-program, optimizing compilers (esp profile-guided) if possible. I used SGI’s for this at one point. I’m not sure if LLVM beats all of them or even has a profile-guided mode itself. Haven’t looked into that stuff in a while.

              Notice that most of this doesn’t take much brains. A few take little to no time either. They usually work, too, giving anything from a small to vast improvement. So, they’re some of my generic options. Via metaprogramming or just good compiler, I can also envision them all integrated into one language with compiler switches toggling the behavior. Well, except choosing fastest component or algorithm. Just the incidental stuff.

        1. 4

          I hope they change the tag line: “Rust: The programming language that empowers everyone to become a systems programmer.”

          In my experience, “systems programmer” is used to mean “I write programs that are hard, so I can look down on people who do mere ‘scripting’ programming”

          1. 9

            I think Wikipedia sums it well:

            […] application programming aims to produce software which provides services to the user directly (e.g. word processor), whereas systems programming aims to produce software and software platforms which provide services to other software, are performance constrained, or both […]

            Source: https://en.wikipedia.org/wiki/System_programming

            1. 3

              I’ve just now realized that to me, “systems programming” is basically equivalent to “not having to care about unicode”.

              I really like this.

              1. 1

                So an alternative to find would not have to deal with filenames or directory names that contain Unicode?

                Or if you’re writing a database engine, you don’t have to support Unicode?

                I’m being a tiny bit sarcastic, but it’s also interesting to investigate the boundary between “user” and “systems” programming.

                Edit wording

                1. 1

                  It’s certainly a matter of perspective to a large degree (one developer’s platform is another developer’s application), but from where I sit, yes, find, databases and such are definitely more in the “applications” direction.

                  The “systems programming” I deal with consists of things like filesystems (please please please don’t shove unicode in there), block storage layers, thread scheduling, memory allocators, etc.

                  1. 2

                    The “systems programming” I deal with consists of things like filesystems (please please please don’t shove unicode in there)

                    Hah, doesn’t one of the new macOS file systems do this? IIRC, they require valid UTF-8 and I think even do normalization. With that said, I am not knowledgeable about file systems, so I don’t actually know at which level of abstraction these rules are implemented.

                    Anyway, I love Unicode. A significant fraction of the work I’ve done in Rust land has involved Unicode in one form or another. But my area of interest is text search, so that makes sense. Whether that’s “systems” or not, I dunno. ¯\_(ツ)_/¯

                    1. 3

                      Hah, doesn’t one of the new macOS file systems do this?

                      I haven’t really been paying too much attention to Apple recently, though it certainly seems believable – their filesystems have been case-insensitive since time immemorial, so madness of that sort was already well-established there…

            2. 6

              I thought this was a really great description of both the ambiguity of the term and its origin.

              http://willcrichton.net/notes/systems-programming/

              1. 4

                Thanks for sharing. This article does a good job of exploring why this is such an ill-defined term. In particular I find the early pre-Osterhout definitions to make much more sense than the modern usage. His dichotomy really seems to have set the discourse back significantly.

                1. 1

                  Huh, I thought the definitive treatise on the nature of systems programming was this.

                2. 6

                  We’re not fully happy with the tag line currently and happily take suggestions. “systems programming” being a fuzzy term is one of the problems. The spirit is definitely what we want, but if someone were to find a better way to phrase it, I’d be very happy.

                  1. 6

                    My translation of “systems programmer” is “we don’t do GUIs”. ;)

                    1. 3

                      Yet many GUIs outside of the web context are written in systems programming languages :)

                      1. 1

                        Sounds like rust alright.

                      2. 4

                        I like the spirit of the tagline. Systems programming is a real thing, it’s genuinely difficult to do correctly - and Rust is helping make that situation better, so that more people can write less buggy systems code.

                        1. 1

                          This is cynical, although sometimes true.

                          1. -6

                            Systems programming is genuinely difficult in a way that, frankly, GUI programming just isn’t.

                            1. 10

                              If you just switch “GUI programming” and “Systems Programming”, this statement checks out, too. Modern GUI programming with backends and networks is a complexity beast. Add translation and such on top and it becomes incredibly hard.

                          1. 3

                            So many hosting solutions around vms, small/light/micro-vms, containers, lambdas… and I still feel the deployment processes and tooling is still far from good enough.

                            1. 8

                              I’m curious, how many of you are using Mutt as your daily email client at work? How do you cope with calendar invites, frequent HTML emails, …?

                              1. 3

                                I use mutt for personal email, so calendar invites is not an issue for me. I also have mutt use lynx to handle the case when the sender only sent HTML (usually, if there’s an HTML section, there’s also a plain text section). For work, I use whatever they give me—I like keeping a separation between personal and work stuff.

                                1. 1

                                  Do you mean invites aren’t an issue because you don’t use them or because you solved this? If so, how?

                                  I read in another comment that it’s just html, and to be fair as I come to think of it, it’s been a long time since I had to care about mutt and calendars, so maybe it was just a dumb link to click through the terminal browser.

                                  1. 2

                                    I don’t use invites or calendar things via personal email, and if anyone has sent me one, I haven’t noticed.

                                    I did start using mutt at a previous job where I had to chew through a ton of daily mail (basically, all email sent to root on all our various servers were eventually funneled to me) and I found mutt to be much faster than Thunderbird (which should indicate how long ago this was). It was using mutt for a few weeks that prompted me to switch away from elm (which really dates me).

                                2. 3

                                  IIRC, when I used mutt regularly, I used to have it pipe html emails straight into elinks to render them inside mutt. Didn’t need calendaring at the time.

                                  1. 2

                                    I gave up my resistance of modern email quite some time ago; it’s simply too much hassle, personally speaking, dealing with calendaring and rich media content in email to still use a console based MUA, but that being said I really miss the simplicity and lightweight of Mutt.

                                    Mutt was my go-to client for many, many years, and I feel tremendous nostalgia when I am reminded that it’s still actively maintained and indeed has a user base. Bravo. :-)

                                    1. 2

                                      How many emails do you handle a day? I do about 200, though I need to read or skim all, I only reply to about 1/10th of them… but I can’t imagine keeping up with that in any of the gui clients I have had. With mutt, it feels like nothing.

                                      1. 1

                                        I’m trying to do more and more with mutt, gradually using the GUI client less. Still haven’t configured a convenient way to view html or attached images but the message editing is nice. I hook it up to vim:

                                        set editor='vim + -c "set ft=mail" -c "set tw=72" -c "set wrap" -c "set spell spelllang=en"'
                                        

                                        This mostly formats things correctly, and allows me to touch paragraphs up by hand or with the “gq” command. I can also easily add mail headers such as In-Reply-To if needed. In some ways my graphical client is starting to feel like the constrained one.

                                      2. 2

                                        I’ve been using Mutt for the past 15+ years for personal email and 5+ years for work - even with Exchange IMAP (special flavour) at one point.

                                        I mostly ignore HTML email - either there’s a text/plain part or HTML->text conversion is good enough - there are occasional issues with superfluous whitespace and it can look a bit ugly when plenty of in-line URLs are being used but these are not that common.

                                        For calendaring I still use web - we’re on G Suite - but am hoping to move to Calcurse at some point (still not sure how to accept invites, though). Bear in mind, calendar != email, and Mutt is an email client - once you accept it, you’ll be much happier :^)

                                        1. 1

                                          I used it 2015-mid 2017 but ended up moving back to Thunderbird and even web clients. It wasn’t worth the effort. If I didn’t have to handle all my configs to get a decent setup (imap, gpg, multi-account, addresses) then I’d consider using it again. I love the idea of not having to leave my term.

                                          1. 1

                                            I use mutt daily and have my mailcap set to render html email in lynx/w3m/elinks. It’s sufficient to see if I then need to switch to a GUI mail client. For GUI, I have previously used Thunderbird with DAVmail and currently just use the Outlook client.

                                            1. 1

                                              I use (neo)mutt as my daily personal email. HTML isn’t an issue, but forwarding attachments and dealing with calendar invites is embarrassing.

                                              Usually I use the bounce feature into my work email (Protonmail), which causes spf-related spam flags to get set, but generally gets the job done.

                                              I self-host my email so the pain threshold is quite high for me to start configuring RoundCube (or whatever the kids today use) or even IMAPS.

                                              PS. not using Google is a bit embarrassing as well, as the email and Nextcloud calendar are so disconnected, but it works better than mutt ;)

                                            1. 5

                                              I like the sentiment but think there are a couple of ways the essay could have developed it’s ideas further:

                                              1. One of the simplest ways to significantly improve the value of code review is to comment on your own PRs: not extensively, just two or three clarifications. We empirically know this reduces the number of defects that slips through, but nobody ever talks about it as a technique.

                                              2. The essay and (1) are partial answers to the same implicit problem: code review is supposed to be seen in a different viewpoint than code execution. But all of our tools only support seeing the “concrete” view of code. Trying to encode view information in the commit messages or PR comments are ultimately just hacks around that problem, and we can only “properly” solve it via better means of overlaying views on top of a codebase.

                                              1. 2

                                                I really like (1) and try to apply it often. Sometimes I know that someone will see my change, not knowing what was the purpose and not reading the original issue, and will let a comment because he lacks context or just trying to double check something.

                                                By commenting the “hot spots” I’m sure that my PR is easier to read and will help for a better review.

                                                1. 1

                                                  I’d be interested in reading about (1)–do you have a reference I could look at?

                                                  I’ve always felt like the diff should be readable without comments, but that opinion is not based on any real evidence.

                                                  1. 2

                                                    Best reference for this is here, where annotated code reviews had significantly fewer defects than reviews without them. The hypothesis is that it’s because writing annotations makes your oversights more obvious to you, kind of like how writers read prose aloud to see if it flows funny.

                                                    1. 1

                                                      Thanks, I’ve added it to my collection of notes on code reviews.

                                                1. 17

                                                  I think the distinction ought to be made between ‘Using Kubernetes’ and ‘Setting up your own Kubernetes cluster’.

                                                  The former is pretty easy, and depending on your choice of provider can make deploying complex applications more straightforward than it would have been in the past. You get some degree of HA/redundancy for free by going this route.

                                                  As for setting up and maintaining your own cluster, that’s a totally different proposition, Kubernetes itself is a beast, and deploying and maintaining it will take up a heap of your time.

                                                  1. 3

                                                    I completely agree. For developers, using kubernetes makes deployment and configuration a (relative) breeze , but maintaining and upgrading a kubernetes cluster is just as much work as maintaining physical servers, and it’s not always obvious what to do as kubernetes has SO MANY moving parts (for better and for worse).

                                                    1. 2

                                                      On the other hand, many developer forget buildpack based deployment (aka heroku-like) that makes it even more a breeze.

                                                      I think they mostly forgot about it because it’s not hype anymore… It offers less flexibility, but offers great comfort that is very valuable to many projects. In addition, you’re not that tighten to the provider since buildpacks are widely supported.

                                                      1. 1

                                                        I think both has merits. There are start-up costs associated with both (creating the definitions, what goes where, lots of YAML for kubernetes), but once it’s running it Just Works™.

                                                        The upside of kubernetes, in my personal opinion, is that you can define a lot of things together (services, containers/pods, disk provisioning, etc.) in one push and expect it to work given the cluster has enough resources. Buildpacks are focused more on a single application.

                                                        1. 1

                                                          I’m not familiar with deploying to Heroku, but I recently worked on a small app that started life on Google App Engine, which I believe deploys similarly?

                                                          The issue we ran into was when we wanted to run up external dependencies that the provider didn’t offer natively, a Redis instance to support a Celery worker for example. It’s these sort-of-external deps that kubernetes makes really easy to deploy.

                                                          1. 1

                                                            I think it’s similar yes.

                                                            On Heroku you have the add-ons that provide many other softwares that you can use along your instances: https://elements.heroku.com/addons

                                                            The main problem with Heroku that people have is that it become very expensive very quickly compared to other solutions.

                                                    1. 13

                                                      At the end I was looking for Python but it wasn’t even listed. :(

                                                      Python is…

                                                      • syntax light and readable
                                                      • integer overflow-proof unless you have a number larger than the memory of your entire machine
                                                      • not intended for creating metalanguages

                                                      It’s only downside (in my opinion and limited experience) is that it usually will be slower than something comparable in a compiled language.

                                                      1. 5

                                                        For me, the One Thing missing from python is a rigorous static typechecker. I miss that a lot when writing python code. That said, I do generally enjoy working in the language.

                                                        1. 1

                                                          I share the feelings. I’d add that the common functions that you might expect like map/filter/sort/… have sometimes weird names or syntax and reminds me PHP…

                                                          1. 1

                                                            I never understood this complaint/desire to add static typing to languages that are completely antithetical to the idea. Not every feature that exists in other languages should be added to every language (that leads to C++, Rust and PHP). Python is a dynamic language and it doesn’t make sense to bolt rigorous static typing on top, and it’s never going to be completely sound, because of its inherent dynamic nature. Why not use a language with a sound strict typing system, like OCaml or Haskell or Elm or what have you?

                                                            1. 3

                                                              Actually, I’d even be happier if Python didn’t include lambdas, functools and such. Having no support for functional programming would be way less frustrating than having half-assed support for functional programming, especially given that the community frowns upon their use anyway!

                                                              1. 1

                                                                I strongly prefer OCaml, Haskell, Elm, etc. But those languages don’t have anywhere near the community buy-in as Python, so there’s much more friction in using them for a project (especially a collaborative one).

                                                              2. 1

                                                                Did you checkout mypy and the typing module? I had the same feeling, and am super happy with both.

                                                              3. 3

                                                                It’s only downside

                                                                It has many other downsides.

                                                                • Bananas for data types; no facilities for arrays (without extensions like numpy)
                                                                • Crap “error” handling: Dynamic unwind is the last thing we want for error handling, but
                                                                • 1990’s module system aka PYTHONPATH means everyone invents their own plugin system. Hooray for virtualenv, you’ve just traded one problem for two.
                                                                • Zero legacy support. Python applications are expected to either be sealed (and risk platform bugs, of which there have been many) or be rewritten (often substantially) every time there’s a new release. Hopefully this is changing – Python3 has settled down considerably, but I need another ten years.

                                                                I could go on. Really, Python is one of the worst successful languages I’ve ever seen or used. and I’m so glad other languages are eating its lunch (go, rust, cobol) – even though I don’t particularly rate those languages (although admittedly for other reasons).

                                                                1. 1

                                                                  Bananas for data types; no facilities for arrays (without extensions like numpy)

                                                                  I don’t really think it’s a big deal to need extensions for data types, if it wasn’t for Python’s “batteries included” mantra. It’s more like “a few very specific batteries of varying quality are included”.

                                                                  Crap “error” handling: Dynamic unwind is the last thing we want for error handling

                                                                  Could you unpack that a bit? I’m genuinely interested to know what is wrong with its exception handling and what alternatives are better.

                                                                  1990’s module system aka PYTHONPATH means everyone invents their own plugin system. Hooray for virtualenv, you’ve just traded one problem for two.

                                                                  Yeah, modules in Python are a bit fiddly.

                                                                  Zero legacy support.

                                                                  I can imagine that’s annoying when working on an old application, but I do think improvements need to happen, and sometimes the best way forward is to do an overhaul instead of lugging around broken stuff forever. In this, Python is a bit of a victim of its own success; the reason it was so hard to switch to Python 3 was mostly in the 3rd party libraries. This is tricky to get right (but it can be worse; look at PHP with its ancient legacy cruft sticking around and continually breaking very large things on each major version), and I really wonder how the new languages like Go and Rust fare with legacy support. They haven’t been around for as long as Python.

                                                                  1. 2

                                                                    Bananas for data types; no facilities for arrays (without extensions like numpy)

                                                                    I don’t really think it’s a big deal to need extensions for data types, if it wasn’t for Python’s “batteries included” mantra. It’s more like “a few very specific batteries of varying quality are included”.

                                                                    A really useful data type is the “table”, but it’s extremely difficult to write one in Python, so nobody bothers. Everyone just writes:

                                                                    for row in q.fetchall():
                                                                    

                                                                    all day, and think this is the best they can do. But “my database” knows what a table is. Its tables are pretty good. Why can’t I implement a table type that’s worth half that? Why can’t I even approach sqlite-level of functionality? If Python is so great, why is something that everyone uses every day nearly impossible to implement in Python?

                                                                    Another really useful data type is a “date”. Dates are also hard to implement in Python, but this one people have tried. Unfortunately, the one most popular had a bug involving DST east of GMT creating a lot of weird problems for people. Dates have a continuous nature that the integer usually used to represent them doesn’t have, which also causes strangeness for people. Intervals are really similar to dates – you can add them, but intervals don’t have timezones. Dates do. This causes more bugs. And so on.

                                                                    Getting batteries included with your golf cart is stupid because you’re still driving a golf cart.

                                                                    Crap “error” handling: Dynamic unwind is the last thing we want for error handling

                                                                    Could you unpack that a bit? I’m genuinely interested to know what is wrong with its exception handling and what alternatives are better.

                                                                    Common Lisp has a “condition system” which is better.

                                                                    To separate the language-specific element: Conditions can be implemented in Python trivially. Most of the issue with error handling is cultural, and people continue to argue between “exceptions” (e.g. longjmp, dynamic-unwind, nonlocal goto, etc), and “error codes” – like the issue is merely signalling exceptional state one way or another or something like that.

                                                                    To see what happens when you think that the point of errors is to tell people about them, look at the innovation in this space you’re probably much more familiar with: So-called “railway-oriented programming” or A+ Promises. They’re the same thing. Stack unwinds, but we never rewind.

                                                                    That’s the trick: We don’t just want to say “help, I can’t proceed any further”, we want to say “I can’t proceed any further unless…” – and that’s exactly what conditions give you.

                                                                    If you want to imagine what this could have looked like in Python, imagine instead of an except IOError, e: you could say when IOError, e: do_something() and then do_something() could return so that whatever was trying to write to the disk (or whatever) could retry. You could implement this with functions and while loops, but that would never fix all the other libraries that are still wrong.

                                                                    but it can be worse; look at PHP with its ancient legacy cruft sticking around and continually breaking very large things on each major version

                                                                    Oh indeed. I’m aware things can always be worse. But if I’m going to fantasise about how things are going to be better, I’m going to shoot a hell of a lot higher than PHP.

                                                                    1. 1

                                                                      A really useful data type is the “table”, but it’s extremely difficult to write one in Python, so nobody bothers.

                                                                      What exactly would you expect from a table type that’s better than the “for row in fetchall()” style functionality? The database engines I know about will literally return a list of tuples to the client. Sqlite seems to allow stepping through this list to return the tuple at the current point a la “cursors”. Or is it more the row-number/column-name type access you’re aiming at here? That’s pretty trivial to implement with “magic methods”. For some weird reason that’s not the default behaviour in psycopg2 but you can ask for a dictionary-like cursor when making the db connection.

                                                                      Common Lisp has a “condition system” which is better.

                                                                      Ah, I see what you mean now. The distinction is about continuable versus non-continuable conditions/exceptions. That reminds me, I’d like to make continuable exceptions easier to handle in CHICKEN, as currently they’re a bit awkward to deal with right now.

                                                                      But if I’m going to fantasise about how things are going to be better, I’m going to shoot a hell of a lot higher than PHP.

                                                                      Thankfully, most of us do :)

                                                                      1. 1

                                                                        What exactly would you expect from a table type that’s better than the “for row in fetchall()” style functionality?

                                                                        Think about what you’re doing inside those for-loops and how similar many patterns you might have there. Some of the ones I see every day:

                                                                        • Reorder (or build a permutation array) the table by one, two, many compound columns. In k, all vector operators are extended to tables by having tables implemented as a list of columns; arrays all the same length.

                                                                        • Join/zip two tables together (exceptionally common). Gross in Python, but in k this is just ,

                                                                        • Determine if some table is inside another table.

                                                                        • Group some table rows by some columns.

                                                                        • Use a column as a rule on other columns. For example, if I want a table of switches, and one column to specify which switch to flip, in q this is

                                                                          @[t;t`rules;@[;;not];til count t]
                                                                          

                                                                          In Python, you need, if row-ordered something like:

                                                                          for x in t:
                                                                            x[x["rules"]] ^= x[x["rules"]]
                                                                          

                                                                          or if column-ordered:

                                                                          for i,x in enumerate(t["rules"]):
                                                                            t[x][i] ^= t[x][i]
                                                                          

                                                                          Neither is great, and I’ve seen worse contortions trying to rewrite it in SQL…

                                                                        • Deleting rows from a table (usually simulated with list.filter, but this conses a lot)

                                                                        • Upserting (often simulated with an index)

                                                                        And so on.

                                                                        The database engines I know about will literally return a list of tuples to the client

                                                                        One way to think about this: The “database engine” is just another programming language, and it’s another one that’s better than Python at tables. The challenge is to have tables in not a database engine.

                                                                        It’s funny, because as soon as you put tables in there, plus “a little bit more”, you have a “database engine”, but exactly how much “a little bit more” is, and what you get for it makes you wonder why you just didn’t do it in Python (or C or Rust or Go whatever) to begin with.

                                                                        Back in the day, the reason “the database” was separate was because a separate team managed it, but I feel like we’re past this now. Keeping tables out of languages isn’t some layer-violation, it’s a space of real problems people are working on every day that language designers are just ignoring for inertia reasons.

                                                                        Ah, I see what you mean now. The distinction is about continuable versus non-continuable conditions/exceptions.

                                                                        Well it’s one solution. I’m not closed to others, but it’s an obvious one that’s “better” by some definition. It’s worse by another (longer code) which might also be important: I put a fair amount of effort into fixing ECL’s file/IO “exceptions” to be restartable, but I don’t think anyone ever used them but me. Lisp is great, but people keep writing Java in it…

                                                                        I’m still thinking about how language can help with this.

                                                                        1. 2

                                                                          Think about what you’re doing inside those for-loops and how similar many patterns you might have there.

                                                                          Hm, that’s thought-provoking, thank you for that! I see what you mean now, never really considered it to be a huge problem, but these patterns do occur over and over.

                                                                          It’s funny, because as soon as you put tables in there, plus “a little bit more”, you have a “database engine”, but exactly how much “a little bit more” is, and what you get for it makes you wonder why you just didn’t do it in Python (or C or Rust or Go whatever) to begin with.

                                                                          In most cases I would argue you didn’t write the right query to return just the data you need in the right form. Nine times out of ten you see people writing horribly contorted code that’s dog slow in their programming language (often performing tons of extremely dumb queries) to massage data into shape, in a way that could be done much better and more efficiently with SQL (often with a single query instead of many). So even if you have the right tools people will abuse them.

                                                                          Back in the day, the reason “the database” was separate was because a separate team managed it, but I feel like we’re past this now.

                                                                          I would tend to disagree: the most important part (for me) about a database are the ACID properties offered by RDBMSes. It’s a separation of concerns; you don’t want your language to implement a storage engine, just like you don’t want your language to implement a raw file system; leave that to the OS kernel. You could do both in a library of course, but I’d much prefer a specialized separate tool to do it. Nevertheless, having good direct support for “tables” like you mention would be nice and a good and natural extension for dealing with result sets or tabular data that doesn’t need to go to an external database.

                                                                          I put a fair amount of effort into fixing ECL’s file/IO “exceptions” to be restartable, but I don’t think anyone ever used them but me.

                                                                          My hat’s off to you! We need more people to put effort into making existing good tools even better.

                                                                          1. 1

                                                                            In most cases I would argue you didn’t write the right query to return just the data you need in the right form. Nine times out of ten you see people writing horribly contorted code that’s dog slow in their programming language (often performing tons of extremely dumb queries) to massage data into shape, in a way that could be done much better and more efficiently with SQL (often with a single query instead of many). So even if you have the right tools people will abuse them.

                                                                            Yes. That happens very often. But I want to stress that tables don’t just live in the database.

                                                                            I have an ad server that can either retrieve ads from its local database, or from a remote server (using HTTP). The publisher (client) requests ads from me, and I’ll basically be an aggregator. If the publisher asks for 10 ads, and the advertiser gives me 3, I might ask for 7 from another advertiser and glue them together.

                                                                            The ad response is a table - each row representing a different ad, and each column representing some attribute (like the title, description, click-URL). I’m doing asof join (basically a merge-sort) to glue these together since I know the client may only take the first few ads so everyone who does this puts the higher-value ads at the top.

                                                                            I’m given search keywords, so I do a query on this table – it’s a virtual table really, since it spans multiple databases (local and remote) but you can see this is clearly a table lookup made difficult by committee.

                                                                            Knowing that, look at the schema Yahoo uses (starts around page 87). Do you see that table? How about when Google does it? Do you see the table now?

                                                                            the most important part (for me) about a database are the ACID properties offered by RDBMSes

                                                                            As soon as I discovered logging, I realised I never needed ACID Again. I rarely use an ACID database these days, and my application design has become a lot simpler as a result.

                                                                            I remember I noticed that many business applications want their database to remember all the changes. And who made them. So many CRUD applications will in addition to all the insert/delete/update operations, duplicate those into an “audit” table of some kind. There may be even some business processes for recovering/rollback/cherry-picking values from that table.

                                                                            However another way you can do this is to imagine you have a single “changes” table. Inserts to it are cheap! it’s just file append! Then all of your queries go to materialised views (re)built from those changes. In a catastrophic situation it’s trivial to replay the log and get the views back. Or change the schema and replay so you get your data right. No migrations.

                                                                            It’s like patch theory for databases.

                                                                            Here you can see we have atomicity when we want it (simply block queries to the new views while you’re building them), consistency (all the new views are built together), integrity (duh), and durability. In fact, this approach is so easy, you’re likely to get it right the first time. Putting b-trees on disks on the other hand is what all the “database engines” do, and to get acceptable performance means handling a lot of edge cases. That makes a lot of code- places for bugs to hide.

                                                                            It’s a separation of concerns; you don’t want your language to implement a storage engine

                                                                            I’m not so sure. Being able to pickle/map disk-objects to values is incredibly valuable so why not a table?

                                                                            k/q supports serialising all data types (including lambdas, btw) so they can be sent over the network or written to the disk. On the disk, a table can become a directory where each column is a separate file. mmap() brings them into memory and their layout is similar enough to their purely-in-memory version that few operations need to know the difference. This feels like an extreme version of what I used to get out of hibernation/pickling, and yet it’s so simple! And look at all I get!

                                                                2. 1

                                                                  Agreed, but I’d say the main downside (beside not amazing performance, even with PyPi) is the lack of meta-programming.

                                                                  1. 1

                                                                    There’s some support for metaprogramming in the form of metaclasses, and you can do lots of magic with magic methods, iterators and context managers. There are even hooks that you can call when a class instantiates from an abstract base class. It simply isn’t part of the culture to do lots of metaprogramming, as magic is frowned upon as not being the “one obvious way to do it”. But there are projects that rely heavily on this stuff. For example, the lxml builder uses magic methods a lot, and Django uses model introspection to autogenerate database migrations.

                                                                    I respect the attitude of Python culture of insisting on simple code (and to be fair, Python code tends to be very readable by default), but it’s not my favourite language. Python is relentlessly imperative and the functional style is really frowned upon, it has no macros (the existing metaprogramming is too clumsy to express certain things) and whitespace indentation makes working with the REPL a total pain in the neck.

                                                                    1. 2

                                                                      I completely forgot about metaclasses, thanks for mentioning it. I actually learnt the basics of FP with Python 1.5 and the lambda/map/filter/reduce which at the time was already “ok, but don’t use it”. I continued to use it sporadically but found that list comprehension actually solved a lot of the use cases where I was using filter/map/reduce (although reduce in list comprehension is a bit of a headache). It’s weird, because I wouldn’t say Python is that imperative from a feature standpoint given that you can pass around functions, methods and classes (and now, even type descriptions), but seems to be, as you pointed it out, more culturally imperative. I wonder why that is, do you know happen to know the reasons behind this attitude/perception?

                                                                      1. 2

                                                                        It seems Guido believes functional programming is hard to understand. Furthermore, it doesn’t fit his idea of Python, see this old Slashdot post (search for “functional programming”).

                                                                  2. 1

                                                                    The need of a fast, static typed Python with metaprogramming is what drove me to Nim.

                                                                  1. 2

                                                                    I guess joining redhat in supporting a release for 10 years. That feels like a /long/ damn time to support a Linux OS release though… yikes.

                                                                    1. 3

                                                                      If they take this decision, it’s probably that they ran the numbers and see it profitable according to their potential customers.

                                                                      My thought is more that there’s probably an issue somewhere if companies prefer to stay on the same OS version for years.

                                                                      1. 2

                                                                        No kidding. Considering how much the the kernel, and hardware/platforms, change in a decade, Canonical has a LOT of backporting work ahead of them. Backporting a security fix written for a kernel that is years newer than yours cannot always be fun.

                                                                      1. 1

                                                                        I think we should all be happy for that. It’s just too bad that Google or Apple aren’t actually contributing to make this standard better.

                                                                        I really liked how the container ecosystem structured itself around a Foundation of actors, trying to actually create a great basis and avoid having 5 different legacy with none actually solving correctly the problem space.

                                                                        1. 1

                                                                          Standards with the contribution of large companies are only to ensure their lead, overly complicated, and usually are not new unified models, rather codification of their existing solutions.

                                                                          Also the standard by these companies would probably be very anglo-centric. OSM is a global community, and it has its strength in that.

                                                                          1. 1

                                                                            One critical difference is that the container ecosystem benefits greatly from having single standard. Map data doesn’t benefit in the same way since you can’t legally copy data across the different systems even if were technically feasible.

                                                                          1. 3

                                                                            Hm, as an organiser of many meetups: I like this, but I’d prefer it to not encourage more meetups to serve pizza.

                                                                            (I have no issue with pizza per se, but moving beyond the “pizza & beer” monoculture important)

                                                                            1. 5

                                                                              Hey now, everyone loves pizza! It’s versatile, readily available, easily eaten without utensils, and can serve most niches for people with dietary requirements or taste preferences. (Beer, on the other hand…)

                                                                              1. 3

                                                                                I do even agree with your points! Pizza is the easiest food to quickly get on short notice with a wide variety of variants. This is not a “I hate pizza and you should feel bad for ever serving it”.

                                                                                But everyone loves pizza until all you serve is pizza. You’d be surprised how much positive response you get when you finally run something with other food.

                                                                                Also, with caterers taking note of meetups as a target, other food gets close to pizza when it comes to convenience and price. Usually, they serve a rolling menu where you can only pick what’s available at that night.

                                                                                1. 3

                                                                                  Oh, totally agreed that too much of a good thing is a bad thing. More variety would be nice - at least pizza places offer non-pizza things if that’s your only option.

                                                                                  1. 1

                                                                                    Hmm what are some other things that you would like to server in place of pizza? Other dishes such as pasta/salads? (I can’t think of a good replacement)

                                                                                    1. 2

                                                                                      One meetup in Chicago does empanadas and those work pretty well. I’ve also seen burritos go over well.

                                                                                      1. 1

                                                                                        Those both sound like good ideas - I guess it really depends on location as well.

                                                                                      2. 2

                                                                                        For larger things, curry/rice is a great alternative that can easily cover many food styles. Bagels are also awesome.

                                                                                        For smaller meetups, any buffet can be made affordable or even be prepared yourself with a short trip to the supermarket and 15 minutes of cutting and slicing.

                                                                                        If you have enough money, any city has a lot of small scale caterers, though they tend to cost a little more then pizza. (Not much, but it may be prohibitive) At least in Germany, getting some food from the restaurant around the corner is usually possible, even if they don’t officially cater. If they are close, they might even bring stuff up to your offer and lend you plates. This definitely becomes easier if you are always at the same location.

                                                                                        My rule of thumb: go to a local sports club, see what they do ;).

                                                                                    2. 1

                                                                                      I suspect you’ve never tried to eat vegan, gluten-free pizza.

                                                                                    3. 2

                                                                                      I’ve gotten some feedback on some of the events I run that having non-pizza options was definitely a thing. I started running one event out of the venue space in a bar, and that’s worked quite well. Lots of food/beverage options there.

                                                                                      1. 1

                                                                                        Yep. There’s lots of way to solve it. I want meetup organisers to be creative. (also, I want meetup organisers not to spend too much time, it may become exhausting)

                                                                                      2. 1

                                                                                        In my previous company (which just raised money) we had trouble to find other “sponsors”, so we tried not to put the usual pizza and beer stuff. The result is that less people came because they had to come back late at home without eating and going to the restaurant for a meetup was too expensive.

                                                                                        We finally setup for the pizza and very few beers, but it felt like people preferred the catering than the talks…

                                                                                        1. 1

                                                                                          Oh, food is important, I just want variety.

                                                                                        2. 1

                                                                                          Pizza isn’t the most healthy, but hey, John Carmack didn’t develop Doom ordering chinese takeout every night :p

                                                                                          1. 3

                                                                                            BRB, registering the “John Carmack Meetup”, where everyone is John Carmack.

                                                                                            It isn’t as much about health. Eating Pizza once a month is fine and if you visit meetups so often that their choice of meal becomes a health issue, you should probably reconsider your meetup habit before your food habit.

                                                                                        1. 8

                                                                                          The timenow.New accepts a pointer to http.Client, so we can pass nil if we want to let the function itself to instantiate the dependency, or we can specify it.

                                                                                          Ugh. In an API intended for consumption by downstream users, magic parameters intended for consumption only by the framework’s developers to accomplish internal testing of the framework’s implementation are an awful architectural pattern that unfortunately have way too much industry currency as “the right way to solve mocking”, currently.

                                                                                          I’ve seen far too many codebases with constructor parameter lists that are an absolute grab-bag of random dependencies with no clear meaning to end users trying to instantiate anything other than “just go with the defaults that magically appear”. It’s a bad pattern that reduces encapsulation (you’ve now given downstream consumers a lot of visibility and reach into your implementation internals, to the point where you’ve got no guarantee that you’re relying on what you expect you’re relying on at runtime), and it seriously harms the communication of intention to other developers who don’t already have the framework’s internal implementation in their heads (because now you’ve confused the public API with a bunch of information about the API’s implementation)

                                                                                          There are other ways to solve this problem. If you embed httpClient in a wrapper struct, timeNow can depend, directly and internally, on your wrapper, and a good build tool will let you expose an alternate implementation of the wrapper to timeNow when compiling it for testing.

                                                                                          “Injecting” mocked dependencies at test compile time is going to be a lot cleaner in the long-run than watching every constructor in your application explode into a grab-bag of dynamic injection points that are never expected to dynamically vary during a production run anyways.

                                                                                          1. 5

                                                                                            The strictly-better solution would be to define

                                                                                            type Doer interface {
                                                                                                Do(*http.Request) (*http.Response, error)
                                                                                            }
                                                                                            

                                                                                            which is implicitly satisfied by net/http.Client. The timenow constructor would take an instance of that interface rather than a concrete object, which would permit the real client in production code, and a mock client in tests.

                                                                                            1. 3

                                                                                              I worked at a company where we did this , but in Objective-C. So I simply had two constructors: one with explicit dependencies, and one that conjures them up and then calls the first one, which I think is slightly nicer than the solution presented in the post. The DI version can be in a private header and no one else needs to care about it.

                                                                                              1. 1

                                                                                                Do you have golang exemples with your solution? I’d be interested to have the same example as presented but as you describe it!

                                                                                              1. 4

                                                                                                Then you just print the QR code and then securely delete it.

                                                                                                Then microwave the printer.

                                                                                                1. 7

                                                                                                  If you’re afraid of the printer, you still can draw it by hand (can take a long time with strong rsa keys, but you could switch to ecc)… At this point you’d have to microwave your screen, your graphic card… and probably also… your whole computer. You shouldn’t also forget to also destroy the device flashing the Qr code then…

                                                                                                  1. 6

                                                                                                    Many enterprisey printers explicitly have a long memory of what they printed.

                                                                                                    1. 1

                                                                                                      I like the idea of drawing it by hand, but I bet it would go way faster with a typewriter that could print out some nice blocky squares… Hmmmm….

                                                                                                  1. 10

                                                                                                    When I first started working remote I also got really lonely. It’s a real thing that I think is overlooked too often. People fail to take into account how effectively being alone impacts your mental health. I found that chatting online and video calls just aren’t the same as actually being in the same room/space as people.

                                                                                                    1. 4

                                                                                                      I had the exact same experience and switching from home to co-working space changed everything. I felt that I had “colleagues” even if not working at all for the same company. I rediscovered that the “coffee time” wasn’t about coffee but about socializing.

                                                                                                      I cannot stress enough that having a clear distinction from working space and personal space is really important.

                                                                                                      1. 8

                                                                                                        I have the opposite experience. I work remotely from my kitchen, and I can spend days without talking to or seeing anyone. No “cabin fever,” whatever that means. I kinda miss coffee table socializing, but only a little bit. In fact such socializing can be quite painful & awkward for me, and I’m glad I no longer feel the obligation to join up at a coffee table..

                                                                                                        I checked out some coworking spaces and my employer said they’d cover the bills but at this point I don’t really see many benefits to it (they don’t even offer free coffee.. I’d reconsider if there was a good coffee maker that goes straight from beans to brew). There are definite downsides, such as the commute. And having to lug hardware back and forth if you don’t plan to always work from the coworking space.

                                                                                                        Now, being lonely can be a problem but my experience is that obligatory lunch/coffee table time with coworkers doesn’t fix it. Time with family or good friends would fix it.

                                                                                                        1. 3

                                                                                                          Very interesting to read someone having the opposite feeling and experience!

                                                                                                          I found that having to commute also helped to put rythm in my day and have justification for being in town and see friends before going back home. Isn’t it something that you miss?

                                                                                                          What your routine like? Do you wake up, have breakfast and stay in the kitchen the whole day for work? Or do you have a more fragmented day?

                                                                                                          1. 5

                                                                                                            What your routine like? Do you wake up, have breakfast and stay in the kitchen the whole day for work? Or do you have a more fragmented day?

                                                                                                            There are plenty of interviews posted on https://remotehabits.com/ with questions similar to these. I’m not affiliated with them. I just find the site useful enough to post a link.

                                                                                                            1. 1

                                                                                                              Thanks that’s a great resource to get new ideas and improve remote days!

                                                                                                            2. 2

                                                                                                              I have it somewhat similar to DuClare. I visit the place about once per week, taking with me an Intel Skull Canyon NUC, and that’s about the right frequency for me. Traffic jams, parking and people get on my nerves, even if I get over the awkwardness of meeting a subset of coworkers. No real life friends to speak of, too.

                                                                                                              I do not have any routine, other than a mild morning coffee. When I feel like it, I do 200 hours a month, when I don’t, I do way less and focus on personal projects. Life is short, don’t do what you hate.

                                                                                                              1. 2

                                                                                                                I found that having to commute also helped to put rythm in my day and have justification for being in town and see friends before going back home. Isn’t it something that you miss?

                                                                                                                No friends. Spending time in town was never really a thing for me. My onsite jobs have always been on the outskirts of town or in the middle of nowhere (e.g. in a monastery). When I had to commute to town (for school), I’d always head straight home anyway.

                                                                                                                What your routine like? Do you wake up, have breakfast and stay in the kitchen the whole day for work? Or do you have a more fragmented day?

                                                                                                                I get up at around 8:55 am, get dressed, brush teeth, sign in on work laptop at 9:05 or so and start working, with a cup of coffee. I might go out and buy something on the lunch break, or I might quickly grab something from the fridge and maybe take a little nap afterwards. Lunch breaks end up taking 45 to 60 minutes. I log out sometime around 17:30, give or take 15 minutes. It’s been a very regular routine so far.

                                                                                                                It works pretty well, though I’d like to get in the habit of starting a little earlier (8:00-8:30), keep the lunch break under 45 mins and get more of that evening for myself.

                                                                                                              2. 3

                                                                                                                For the cost of a months membership you can get a pretty amazing coffee setup at home.

                                                                                                                I order green beans online (dirt cheap and they keep for years), then roast (40 minutes every few weeks), and grind (this is the most expensive part; spend $300 or more on the grinder).

                                                                                                                After that an aeropress or stovetop espresso maker is fine (comparable automatic machines cost many hundreds).

                                                                                                                1. 1

                                                                                                                  Man, the difference between what they call coffee at work and my basic coffee machine with decent beans… I can’t drink that disgusting shit at work without sugar. And they’ve already changed both the machine and the coffee beans supplier. I just don’t understand.

                                                                                                            3. 3

                                                                                                              Agreed. I’ve been working full-time remote for almost four years now. The first year was great. But since then, I’ve noticed a distinct loneliness about it, and I miss interacting with my co-workers more directly. It certainly isn’t for everyone. That said, it has allowed me a great deal of freedom to live exactly where I wanted to live, and I wouldn’t trade that for the world.

                                                                                                              In the meantime, I’ve recently started co-working at a local co-working facility, and I enjoy getting out of the house a few days a week. It makes a big difference.

                                                                                                              1. 2

                                                                                                                This is my experience too. I’ve been remote for a little more than 2.5 years now, and I’m feeling emotionally drained because working from home alone all day just sucks. The freedom is great, but I don’t know that it’s worth it.

                                                                                                                1. 1

                                                                                                                  How much does your space charge per month and does your company cover any of that cost?

                                                                                                                  1. 1

                                                                                                                    This so much. I’m going thru a 4 year “can i do this forever” period. sigh.

                                                                                                                1. 2

                                                                                                                  Configuration of the application is complex and requires inside knowledge of how the app works.

                                                                                                                  I guess it depends what you mean by configuration. If it’s nginx configuration, then, IMO, it shouldn’t be changeable by administrator (the person deploying it). If this person want’s it to run on a particular domain with SSL termination, then it shouldn’t be your job anymore. So to me, serve on localhost, with the simplest options possible and 90% of people will be happy and the other ones will find gluing things together easier.

                                                                                                                  I still think docker and docker compose is the right choice

                                                                                                                  Maybe you should just offer a Docker container that has frontend + backend served on localhost, and then simply use for yourself a directory with how you run it, a bit like lobsters that has a repo with the app, but then doesn’t really care how you run it (but the deployment scripts here https://github.com/lobsters/lobsters-ansible).

                                                                                                                  I don’t think there’s a definitive answer to your problem, but just reading this, I felt you had a lot on your plate and tried to offer something (complete deployment instructions) that vary way to much from release to release.

                                                                                                                  1. 2

                                                                                                                    The current things you need to configure is the domain name for the frontend and the api, the password for the sidekiq admin, generate a rails secret key, an api key for mapbox and setup the email details for sending error messages.

                                                                                                                    I think part of the problem is I haven’t decided how easy it should be. I kind of imagine a system where you just pull down the containers and then a setup guide asks you a few things like what your domain name is and then the rest is done for you. But I think this might be too much work for me now.

                                                                                                                    I think its probably fair to expect the user to know how to host things but not know how my app works so I can leave all the nginx and lets encrypt stuff up to the hoster and just make sure the instructions on how to set up my stuff is clear.

                                                                                                                  1. 4

                                                                                                                    This seems to be a lot of, erm, work. Is there a spin of OpenBSD or another BSD that just kinda… works out of the box?

                                                                                                                    1. 2

                                                                                                                      OpenBSD-based distros show up periodically but usually disappear. I occasionally Google them to see what’s out there hoping we eventually get an Ubuntu or Mint… even a fraction of that focused on critical things… based on it. The ones I remember finding were Anonym.OS, OliveBSD (link’s dead), and MirOS. Last one still has a website up.

                                                                                                                      1. 1

                                                                                                                        TrueOS, nee PC-BSD, based upon FreeBSD?

                                                                                                                        1. 1

                                                                                                                          This is close to what I was looking for. I see Project Trident is a spin-off of that…

                                                                                                                          1. 2

                                                                                                                            GhostBSD too.

                                                                                                                            TrueOS itself was a ready to use desktop, but now they’re moving towards just being a fork with some differences (LibreSSL, OpenRC etc.)

                                                                                                                        2. 1

                                                                                                                          I’ve been very happy with NixOS for that. I’m using it at work for +6months and when I received my new xps13, it was so straightforward to have something close to what I’m used to, that it would be very hard for me to go back to something else…

                                                                                                                        1. 4

                                                                                                                          Here is a little story about how bad coding interviews when they are automated…

                                                                                                                          I recently did a coding test with Amazon and had to solve little code challenges. It was in Ruby (I chose among several options among Javascript and C++) and in one of the task I had to compute the distance between two points.

                                                                                                                          The issue was that to do that (there might be other ways, that I don’t know), I needed to use the square root function, which (in Javascript and Ruby) was in an external package, but using the Math package wasn’t possible on the coding evironment used by Amazon (I checked and it was the same in javascript)…

                                                                                                                          I throught that since I already knew how to get the distance, I could just look for a good enough approximation algorithm on wiki and then implement that quickly. I did that and it correctly solved the 5 tests with the problem, so I was happy. I commented specifically why I did that and that it might fail in some cases. I thought that this was even the goal of the test at some point…

                                                                                                                          In the end, several other tests passed and one failed (probably because of the precision of my sqrt function), not because it wasn’t correctly solving the problem, just because restrictions have been set (that I wouldn’t have had in my daily job), and despite looking for a fix to make it work, it failed. I like to think that if a human would have been present, he would have seen this positively watching a candidate find solution to constraints put upon his way.

                                                                                                                          Nethertheless, I do understand that these automated tests are a good way to filter candidates, but the one I did were almost always annoying.

                                                                                                                          1. 8

                                                                                                                            I spent the evenings of the next three weeks brushing up on my algorithms and data structures

                                                                                                                            Why, why do companies do this? Am I being hired to implement the STL? I don’t remember how to balance a red-black tree and that’s okay. I don’t memorize things I can look up in ten seconds.

                                                                                                                            Now, it is reasonable to maybe expect people to know the performance characteristics of different data structures (don’t used a linked list when you need a hash table, don’t use a hash table when you need a tree, etc) but even then it’s silly to expect someone to know your pet data structure inside and out.

                                                                                                                            I’m much more interested in knowing how you’d solve a problem, not what trivia you know.

                                                                                                                            1. 2

                                                                                                                              Yeah, for me that’s just nonsense. See how someone breaks down a complex problem, how one asks questions when they need more info before proceeding, see how their average code looks like.

                                                                                                                              But even specifically knowing the performance of certain data structures is something only very specific job descriptions should have.

                                                                                                                              Most tasks should anyway go through iterations of correctness before going through performance polishing (if it is ever needed).

                                                                                                                              If you know specific algorithms by heart you either: just freshly studied them, you had to look them up because they told you they might ask or you are someone with a not normal memory. Maybe that’s the type of person they want to hire or they are just following silly “trends”.

                                                                                                                              1. 1

                                                                                                                                I guess because it’s a black and white subject, mostly removing any implementation details so it’s quick and “fair” to judge a broad pool of candidates. Nonetheless, it’s pretty far from our daily jobs…

                                                                                                                              1. 3

                                                                                                                                The data is very hard to analyse because of living costs and stock values.

                                                                                                                                1. 3

                                                                                                                                  I don’t think anyone should ever touch a GUI framework that doesn’t come with a designer. I mean come on, we solved that problem in the 90s! Why are we designing GUIs via text files in 2018?

                                                                                                                                  1. 4

                                                                                                                                    Some people actually prefer to create GUIs in text files. This is because it’s possible to understand the structure of GUI in a better way. Also it allows to create more sophisticated UX than what’s possible with designers.

                                                                                                                                    The drawback is a lack of instant feedback on how the UI will actually look like. And learning curve is worse I suppose.

                                                                                                                                    So I’d say both of approaches have their advantages and disadvantages, and it’s not like one way is definitely better than the other way.

                                                                                                                                    1. 2

                                                                                                                                      This is because it’s possible to understand the structure of GUI in a betterdifferent way

                                                                                                                                      Corrected this for you.

                                                                                                                                    2. 2

                                                                                                                                      First you need to do it via text files before creating the GUI to manage that. Surely it’s a first step in a new combination of technologies to develop UIs. It’s not trivial to build a designer and shouldn’t be considered on the start. Imho.

                                                                                                                                      1. 3

                                                                                                                                        I think what @vegai meant is that they could have used an existing format like QML and parsed that. Right now, it seems you need to write code to lay out your controls which is bonkers indeed.

                                                                                                                                        1. 2

                                                                                                                                          Writing code to lay out controls is not bonkers at all. All the same abstraction tools you have for abstracting over the repeated bits when you write code normally are available when doing so. Expressing things in code makes sense. Rendering a list is just folding over that list, etc.

                                                                                                                                          1. 2

                                                                                                                                            All rendering engines need to have a programmatic solution before they can have a gui designer. Suggesting otherwise is ridiculous. Not only do you sometimes need to create user interfaces dynamically, how exactly is the magic XML going to turn into pixels?

                                                                                                                                      2. 2

                                                                                                                                        Every time I’ve looked at one of those ‘do it for me’ GUI tools for making GUI tools, it’s looked quite hard to use, and always produces absolutely awful code.

                                                                                                                                        1. 1

                                                                                                                                          I guess it’s probably because creating a designer is a huge investment, and that it’s not incompatible with writing GUI layouts in text files. This kind of project, if maintained and used in the future, might have one at some point!

                                                                                                                                        1. 9

                                                                                                                                          It’s really a shame that we can’t pair with other people outside our companies, typically due to stupid shit like NDAs.

                                                                                                                                          All of us have shitty codebases, nobody has secret sauce, we might as well be able to learn together and solve problems.

                                                                                                                                          1. 2

                                                                                                                                            I agree - I wouldn’t even go as far to say pairing on work stuff, but getting together and talking about interests(programming/tech), side projects, or just life.

                                                                                                                                            1. 1

                                                                                                                                              I felt this very strongly when meeting with old colleagues that also changed jobs. Then we’d share our new experiences and how we’d do things and stuff. It’s very stimulating and helps tremendously to get a sense of how to improve!