1. 2

    Don’t you end up writing extra code, just in SQL? I’m all for the efficiency, but depending on the team’s fluency in SQL, it can be more inscrutable than just writing Python or Ruby.

    1. 6

      My understanding is that if the needed operation is a reduction or join, you should absolutely do it through SQL, so that you’re not sending more data than necessary over the network. Or, If it’s a sort, and the table is indexed (which it should be if you need sorted query results), then you should also be doing that through SQL.

      1. 4

        The trade-off is largely the same as optimizations. I had a long-winded answer elsewhere, but the quick version is that if you’re doing a trivial one-off thing, it really doesn’t matter, but if you need performance, it’s worth taking a look. I had an intern this summer whose app was literally yanking all tables into RAM for most page loads, but since that meant pulling in all of about 200 kB of data, and the app was internal-only and only used for a couple hours a month, I really didn’t see a lot of value in making him redo things. On the other hand, I routinely bypassed Active Record on another project because speed and network usage really mattered.

        1. 2

          In my experience, that extra code in SQL will be much better in almost every dimension, perhaps because it’s a DSL suited to the task. If the team doesn’t know SQL, they should learn it – the ROI will be enormous.

        1. 8

          No “generic” library or framework I’ve seen ever has been able to deliver 100% re-usability. Even string libraries aren’t entirely reusable; for example, constant-time comparison is required in many security applications, but non-security applications tend to favour raw speed. Of course you could add a flag to make it more generic and re-usable.

          If you keep adding flags like this for components that are large enough you end up with so many flags for each different kind of sub-behaviour (or so many versions variants of the same component) that it becomes unwieldy to use, maintain and performance will suffer too.

          That’s why “use the right tool for the job” is still great advice, and so is Fred Brooks’ old advice to “build one to throw away, you will anyway” when building something new.

          1. 4

            I’ve always worked toward the “guideline” that an abstraction should shoot to cover 80% of the problem, but should be very easy to “punch through” or “escape” for that last 20%

            If possible, I won’t “add a flag” to support a feature, but will instead try to write the library in a way that allows it to be disabled or skipped when needed. Suddenly the worry of the “perfect abstraction” goes away, and you are left with a library that handles most cases perfectly, and allows another lib or custom code to take over when needed.

            1. 3

              That’s a very good approach. I also like the opposite approach, which is the “100% solution” to a narrowly (but clearly!) defined problem. The Scheme SRE notation is an example of this, as is the BPF packet filter virtual machine.

              This allows you to make a tradeoff to choose whether a tool fits your needs.

              1. 1

                I’ve always worked toward the “guideline” that an abstraction should shoot to cover 80% of the problem, but should be very easy to “punch through” or “escape” for that last 20%

                I always liked Python’s convention of exposing everything (almost; I’m not sure if the environment of a closure is easily exposed), and using underscores to indicate when something should be considered “private”.

                I emulate this in Haskell by writing everything in a Foo.Internal module, then having the actual Foo module only export the “public API”.

              2. 1

                This seems like something that should be solved outside the library that deals with string manipulation. For example, in Clojure I’d write a macro that ensured that its body evaluated in a constant time. A naive example might look like:

                (defmacro constant-time [name interval args & body]
                  `(defn ~name ~args
                     (let [t# (.getTime (java.util.Date.))
                           result# (do ~@body)]
                       (Thread/sleep (- ~interval (- (.getTime (java.util.Date.)) t#)))
                       result#)))
                

                with that I could define a function that would evaluate the body and sleep for the remainder of the interval using it:

                (constant-time compare 1000 [& args]
                   (apply = args))
                

                I think that decoupling concerns and creating composable building blocks is key to having reusable code. You end up with lots of Lego blocks that you can put together in different ways to solve problems.

                1. 6

                  To me that smells like a brittle hack. On one hand you might end up overestimating the time it will take, thus being slower than necessary, or you could underestimate it, which means you’d still have the vulnerability.

                  Also, if the process or system load can be observed at a high enough granularity, it might be easy to distinguish between the time it spends actually comparing and sleeping.

                  1. 1

                    I specifically noted that this is a naive example. This is my whole point though, you don’t know what the specific requirements might be for a particular situation. A library that deals with string manipulation should not be making any assumptions about timing. It’s much better to have a separate library that deals with providing constant timing and wrapping the string manipulation code using it.

                    1. 6

                      Except in this case constant time is much more restrictive than wall-clock time. It’s actually important to touch the same number of bits and cache lines – you truly can’t do that by just adding another layer on top; it needs to be integral.

                      1. 1

                        In an extreme case like this I have to agree. However, I don’t think this is representative of the general case. Majority of the time it is possible to split up concerns, and you should do that if you’re able.

                        1. 5

                          But that’s the thing. The temptation of having full generality “just around the corner” is exactly the kind of lure that draws people in (“just one more flag, we’re really almost there!”) and causes them to end up with a total mess on their hands. And this was just using a trivial text-book example you could give any freshman!

                          I have a hunch that this is also the same thing that makes ORMs so alluring. Everybody thinks they can beat the impedence mismatch, but in truth nobody can.

                          I guess the only way to truly drive this home is when you implement some frameworks yourself and hit your head against the wall a few times when you truly need to stretch the limitations of the given framework you wrote.

                          1. 2

                            My whole argument is that you shouldn’t make things in monolithic fashion though. Instead of doing the one more flag thing, separate concerns where possible and create composable components.

                            Incidentally, that’s pretty much how entire Clojure ecosystem works. Everything is based around small focused libraries that solve a specific problem. I also happen to maintain a micro-framwork for Clojure. The approach I take there is to make wiring explicit and let the user manage it the way that makes sense for their project.

                            1. 3

                              Monolithic or not, code re-use is certainly a factor in the “software bloat” that everyone complains about. Software is getting larger (in bytes) and slower all around – I claim a huge portion of this is the power of abstraction and re-using components. It just isn’t possible to take the one tiny piece you care about: pull a thread long enough and almost everything comes with it.

                              Note that I’m not really making a value judgement here, just saying there are high costs to writing everything as generically as possible.

                              1. 1

                                You definitely have a point here, on my first job I was tasked to implement a feature, this was a legacy WinAPI app. It involved downloading some data via HTTP (iirc it downloaded information on available updates for the program). Anyways, I was young and inexperienced, especially on the windows platform. The software was pure C mainly, but a few extensions had been coded in C++.

                                So when I wrote my download code, I just used STL iostream for the convenience of the stream operators. Thing is, I was the first C++ code in the code base to use a template library, all the other C++ code was template-free C-with-classes style. The size of the binary doubled for a tiny feature.

                                I rewrote the piece in C, and and the results were as expected, no significant change in size for the EXE. Looking back it makes me shudder what I was tasked to implement and what I implemented. However, I am also not happy with the slimmed down version of my code.

                                Nowadays the STL is just not a big culprit anymore, when you look at deployment strategies that deploy statically-linked go microservices within fat docker images onto some host.

                  2. 1

                    That constant time comparison doesn’t work, because you can still measure throughput. Send enough requests that you’re CPU bound, and you can see how far above the sleep time your average goes.

                1. 11

                  That’s from 2007 but nowadays I would never ever even consider someone if I cannot at least go through some of their solo projects (on some git repo) and ask about one of them directly and technically.

                  What’s important is how they perform at their average and not if they can build X on paper in front of you while terrified.

                  I have been doing programming for more than 15 years and I still am not 100% certain that I wouldn’t not mess up a simple given task during an interview. And that’s because, as most seasoned developers should know, there are SO many different ways to do things:

                  1. the “elegant” (or for some ugly) one liner
                  2. the readable (or for some too verbose) one
                  3. the one handling all crazy edge cases, which might overcomplicate a seemingly simple task, coming from stupid production bugs you encountered
                  4. the fast and easy to implement one

                  And on top of that, gotta figure out which one the interviewer wants you to write and gotta not forget that in language X comparing data is with “a == b” and not “a is b” or whatever, since paper still doesn’t have a syntax checker.

                  1. 9

                    That’s from 2007 but nowadays I would never ever even consider someone if I cannot at least go through some of their solo projects (on some git repo) and ask about one of them directly and technically.

                    I’m sure you might avoid bad programmers that way, but that also cuts out a lot of people who legitimately could do the job.

                    Anecdotal evidence because my search foo is not good enough to find a study again, though I recall seeing them before:

                    https://dev.to/kaydacode/comment/1b1m

                    1. 4

                      I see a lot of debate about how skill should be assessed. It seems fairly a controversial balancing act of wasting the applicants time and wasting the companies time. I agree that its really helpful to see someones projects on a git host but I see others complain that that means working on even more programming while they are not working which is not expected in other industries.

                      Another method is online tests which seem to be hugely hated because they waste the applicants time when the company sends it to you before even reading your resume and then after you pass the test they look at your resume and reject you.

                      And then there are in interview tests which are an even mix of wasting both parties time but reflect poorly on the persons actual skills.

                      1. 2

                        I don’t know but if you don’t enjoy either messing around with new technologies, working on passion projects or just share some code you made during your studies then I’m ok not hiring you.

                        It would be like a painter wanting to work for someone but have nothing they have done earlier (as a study or previous job) to show: they are probably not gonna get the job (and they won’t be asked to sketch something right there during the interview).

                        1. 21

                          I don’t know but if you don’t enjoy either messing around with new technologies, working on passion projects or just share some code you made during your studies then I’m ok not hiring you.

                          With all due respect, this is patent nonsense. This perpetuates the notion that programmers should be spending all of their time programming. It’s also an underhanded way to goad people into working too much: “It’s not a 60 hour work week, it’s fulfilling your passion!”

                          None of my jobs have allowed me to build a portfolio of code that I can show, except for perhaps my current one to a limited degree (and even then anything I change is in the context of a much larger, long-existing project). I have worked very hard at my jobs (often too hard, something I kind of regret) and that has left me with little to no time for side projects, coding or otherwise.

                          Furthermore, what (coding) side projects I do have I have not shared because, quite frankly, I see no need. They aren’t very good and they aren’t useful. They are me tinkering for a personal interest and wouldn’t do well in any code review process. I’d even say my view is nearly the opposite: I’d be reluctant to hire someone who decides to publish practically eveything they do, simply for the sake of sharing.

                          Passion projects are not an indicator of programmer ability. There are simply too many examples of this not being the case to give the assertion any credibility. If I can look at some code, fine. Even still, I’ll probably get a better idea of whether I want to work with someone by talking to them for an hour. I probably speak for more than a few people: I recommend you reconsider your stance.

                          1. 7

                            Particularly when hiring more junior people, 80% of what I care about these days is soft skills like communication, willingness / ability to listen, thoughtfulness, and so on. Know what a function is? Know how to write a for-loop in the language of your choice? Know how arrays work? Great. Now let’s see about those soft skills. Technical skills are easily learned on the job. Soft skills are harder, and in some cases nearly impossible, to learn.

                            1. 6

                              So you forgo technical competence for poorly measurable personality traits? How is that an improvement?

                              There’s certainly a lot more smooth talkers than half-decent programmers around.

                              1. 11

                                I think there is an argument to be made that helping somebody grow their tech skills is both easier and more fulfilling than helping them grow their soft skills.

                                1. 1

                                  Someone has to deliver those milestones while we help grow each other tho.

                                2. 1

                                  Technical competence is at least as hard to measure, and I don’t entirely ignore it, I just don’t try to measure it very precisely. Remember, I’m mostly talking about hiring for junior positions here. If someone comes out of a reputable CS program (or whatever), and can demonstrate some basic general competence, I’m satisfied. And if someone is a smooth talker, at least they can communicate, right? :-)

                              2. 2

                                Even if you can’t/don’t share the majority of your paid work, how many people have really never had an opportunity to fix a bug they’ve run into on an open source project or make some other citable contribution? Or done a side project or just a code sample for some use case that might be useful to others and polished it up enough to share? Or even just filed some well written bug reports against a tool they use? I would never expect or demand to see a fully polished 1000 star open source project from every applicant, but I would be curious how and why someone had never once had the opportunity or willingness to do any of those things. I wouldn’t necessarily rule someone out because of it, but I would expect them to tell me, or I would ask, why they don’t.

                                While I get that some other crafts may make it easier to build up a portfolio “on the clock,” I don’t think that justifies totally dismissing the value of a portfolio as an assessment just because much paid work in software isn’t publicly shareable. Even if you’ve never once had an opportunity to do paid work that is public, is it really unreasonable to expect someone to invest a weekend or so every year or two to build something small that they can share to demonstrate the skills and experience they claim? That seems like a pretty tiny investment in professional development to expect of someone.

                                1. 2

                                  Too, I don’t care why someone wants to program; I only care if they can. Any other decision procedure introduces the possibility of unacceptable bias. If you’re working with a jobsworth who still gets their work done, and you have a problem with that — that’s on you, not on them.

                                  1. 1

                                    I understand your point about not necessarily wanting to share everything publicly (I see it more of a sharable backup than anything else) but you can’t convince me about a programmer who never ever does little personal projects for the sake of it.

                                    It’s really not about some “startup culture” but really about whether they are excited about the stuff and try them out to see. And if all you ever did was because of other people’s requests then you should be aware of it and can let me know.

                                    My suggestion was to help instead of wasting the candidate’s time for nothing.

                                  2. 10

                                    It would be like a painter wanting to work for someone but have nothing they have done earlier (as a study or previous job) to show

                                    Works of arts are generally published, and not under strict NDAs. I don’t think the analogy holds.

                                    Of course it’s possible that the piece is stashed away in an art gallery with a strict no photos policy. If they got that far, it’s pretty likely they have something else to show.

                                    1. 1

                                      What I meant was some previous pieces to use as a portfolio.

                                      1. 16

                                        What I mean is that a working artist is almost guaranteed to generate works they can show off. Either they keep the copyright, or it’s at least photographed and/or published somewhere you can see it.

                                        A working programmer can work for two decades producing code they have no rights to show off, and the code isn’t published anywhere.

                                        And if you comb through organizations with more than a handful of coders, you’re definitely going to find perfectly adequate professionals without a portfolio on github. I would suspect the majority of them don’t have a portfolio, but I don’t have numbers to back it up so I’ll just let you think about it. Does everyone in your company have a github portfolio? If the answer is yes.. are you all twenty three or so?

                                        1. 2

                                          FYI, I worked with people who open sourced their work in the 90s and are now around 40yo and kept doing it, here and there.

                                          It’s really not only about github, that was an example, and I do understand that a certain subset of people don’t have anything that they can show because of the type of work they did but I’m sure they would be experienced enough to inform me of that.

                                          I’m not trying to paint a black and white picture: keep X, drop Y. I’m trying to say that I checking someone’s github is way more valuable and less time consuming than making them doing useless work for free for you under unnatural stress. Then also do listen to them, you shouldn’t be a robot with a flowchart.

                                          1. 3

                                            So really what you’re saying is that you’re OK rejecting a very large swath of qualified applicants in order to have an indicator which has fewer false positives?

                                    2. 17

                                      I don’t know but if you don’t enjoy either messing around with new technologies, working on passion projects

                                      I assure you it is possible to enjoy these things without having a solo doodle on github.

                                      or just share some code you made during your studies

                                      Yeah, I’ve seen people with their coursework and exercises from the 90s hosted on github. It’s quite embarrassing, and doesn’t paint a good picture of the skills they’ve obtained in the twenty years since. If I were them, I’d leave them out. Maybe hiring managers have a lower bar?

                                      I’m ok not hiring you.

                                      Sure. What frustrates people is all these arbitrary rules of this game. Like the little rules that can get you disqualified on a whiteboard puzzle. You think whiteboard puzzles are bad, so you play a different game. Great minds think alike – a bazillion other people have also decided to play a different game. I wish I had written it down every time I saw someone on HN (or here) say something like (I wouldn’t hire you | you can’t possibly be a good engineer) (unless you (know | do | have | are)) (insert thing here). It’d be one massive list. And for every single item on the list, I could find a working professional who wouldn’t qualify.

                                      It’s a crapshoot, and good people get turned down all the time because they didn’t know the rules everyone keeps making up. That’s what gets people frustrated, and that’s why these threads about hiring practices pop up all the time.

                                      1. 1

                                        It’s quite embarrassing

                                        That’s harsh. If someone has exercises from the 90s, I’d thank them for preserving history :)

                                        But I agree about the rules. Screw that. Why can’t everyone have a more free-form thing where you can just tell your story, show something you made if you ever made something that’s not under ten NDAs (and no problem if you can’t show) etc.

                                  3. 2

                                    That’s from 2007 but nowadays I would never ever even consider someone if I cannot at least go through some of their solo projects (on some git repo) and ask about one of them directly and technically.

                                    I’ve been writing software for about as long as you have (around 15 years) and I don’t have much of a portfolio because there are just other things I want to be doing with my free time. Would you mind linking your github profile or whatever? I’m curious to see what your bar is.

                                    1. 1
                                    2. 2

                                      gotta not forget that in language X comparing data is with “a == b” and not “a is b” or whatever, since paper still doesn’t have a syntax checker.

                                      I have to disagree with you on this point. Where I work, we do phone screens with live coding as well as white-board coding during the onsite.

                                      We let the candidate choose their preferred language. For the sake of example, let’s say they choose Python.

                                      If I see someone coding in Python, and they make the exact mistake you pointed out, it raises a flag for me: They don’t have enough coding experience.

                                      It may be that they are just nervous and made a mistake, but that always comes paired with other similar problems in their code.

                                      1. 1

                                        If that works for you, keep it up!

                                        But for me programming languages are just tools to achieve goals, I can’t care less to hire the LanguageX guru. I would find more useful someone who has worked with 10+ languages and knows how to use each of them to solve a specific problem.

                                        I would be more confident having the latter focus and excel with a specific language/framework than the former, as they might want always want to use the language they love the most.

                                        That’s just me though.

                                        1. 1

                                          Being comfortable and familiar with a language is not the same as being a guru.

                                        2. 1

                                          Yeah I tend to agree. The difference between those constructs is something you should just get right. You shouldn’t get it wrong then have some IDE fix it for you. You should just get it right the first time.

                                        3. 1

                                          That’s from 2007 but nowadays I would never ever even consider someone if I cannot at least go through some of their solo projects (on some git repo) and ask about one of them directly and technically.

                                          A few things to keep in mind:

                                          1. People with a lot of side projects almost certainly care about those projects more than they care about your project.
                                          2. Most people’s Github projects don’t have any external management, coworker, customer, or deadline pressure.
                                          3. Some people may resent being judged by their personal projects in a professional context.
                                          4. You’re limiting your talent pool to people with a specific hobby, which is a sure fire recipe for mono-culture.
                                        1. 16

                                          Where’s the evidence that SPAs add to development complexity? Developers like them because they simplify delivering featureful apps. The main criticisms of SPAs is that they make responsive and accessible experiences harder (and require a large js download).

                                          1. 16

                                            Frontend dev here – agree that SPAs simplify some aspects of delivering rich web apps. It’s easy to get one up and running quick, especially with the advent of create-react-app, vue-cli, angular-cli etc, and when you do need to start building a “rich” interactive experience you have what you need already.

                                            But with that said, a ton of incidental complexity sneaks its way in pretty easily and I largely agree with the places where OP identifies it. For example, keeping server and client state in sync usually requires either 1) a non-trivial amount of boilerplate code often with Redux or something similar; 2) a GraphQL-type solution, which can handle synchronization for you at the cost of more conceptual overhead and magic; or 3) not bothering to cache server-side state at all, requiring more AJAX round-trips. This was nearly a non-issue in the last generation of web apps and now it’s an entire cottage industry within webdev.

                                            I think SPAs are appropriate in more situations than OP seems to, and

                                            Third, if you’re implementing a very complicated component then you can use React just for that component. For instance, if you’re building a chat box then there’s really no need to implement your login page in React. The same applies to Vue.js and the rest of the pack.

                                            IME this is easier said than done, but I tend to agree that on a well scoped and understood project, SPA vs MPA is a choice that a team should weigh. Too bad my industry doesn’t seem to agree.

                                            1. 15

                                              In my opinion, the proliferation of things like create-react-app is proof that the complexity of these things is increasing. SPAs feel pretty analogous to the microservice craze: you don’t need to introduce a network boundary to architect software properly.

                                              1. 2

                                                Is that evident if you don’t have some historical perspective? I think to many developers it just seems like “this is how it is” and they don’t see how the many layers have been built up, or that these approaches go in cycles. If you have a much longer arc (i.e. you started developing desktop and web apps beginning in the 90s) it is very apparent where we are in the cycle.

                                                1. 1

                                                  I’m sure historical perspective helps – I’m waiting for the rush of blog posts once people re-discover the more traditional architecture and the cycle begins anew!

                                              2. 13

                                                For example, keeping server and client state in sync usually requires either […]

                                                I think a lot of people who’re using Redux mistake application state (what dialog box is open? which widgets are being displayed? what lists are collapsed? what’s in the search box?) for data state (what’s in the database), and make the mistake of trying to keep all of that in the front end. And usually whatever counts for “sync” between them is something very ad-hoc.

                                                But there is often application state, separate from data state, in many moderately-complex applications, and the SPA approach makes keeping that state across navigations way, way easier. Eg, I go off and do some stuff, hit “back” a few times to go back to where I started, and the same lists are collapsed as they were when I left the page. With an MPA what is the approach to that? You probably don’t want to be round-tripping that state to the server, as part of unrelated requests, or PUTting it every time the user interacts with the UI, or stashing it in a cookie or localstorage. And all of those solutions require deserializing and re-applying the state, which could be troublesome.

                                                1. 5

                                                  IMO, keeping server and client state in perfect sync is unnecessary in many use cases, and would be greatly simplified if folks actually made use of HTTP’s built-in caching mechanisms instead of trying to re-implement caching in JavaScript.

                                                  1. 4

                                                    I’ve never said there are no cases where SPAs are applicable. My plan is to write a followup article about when it is a good choice. Some of my thoughts so far:

                                                    • If the backend supports a mobile app then there will be some duplication in the endpoints. Converting the app to an SPA and building a single backend for multiple clients might lower the total development costs. This needs to be assessed on a case-by-case basis.
                                                    • Progressive Web Apps introduce a new installation method that is superior to app stores. If the increase in sign ups bring enough extra profit to justify building an SPA then it may be a good option.
                                                    • You have convincing evidence that UX is a bottleneck and improving it will bring enough profit to cover the extra development expenses. In general, I think that UX is more of a factor in B2C than B2B (where I’m coming from).

                                                    That’s still work in progress and any comments/ideas are welcome.

                                                    1. 5

                                                      I’ve never said there are no cases where SPAs are applicable.

                                                      Your title is “The Architecture No One Needs”…

                                                      1. 1

                                                        Can we read beyond the title?

                                                        1. 1

                                                          Don’t use clickbait polemic titles and then try to claim a nuanced position.

                                                    2. 1
                                                      1. not bothering to cache server-side state at all, requiring more AJAX round-trips.

                                                      Compared to “classic” site development, isn’t this the same as “fetch a new version of a page”? I get that there are better solutions, but even the baseline seems to be “better” than in the multi-page app model (except that it does add more coordination to rolling out new frontends)

                                                      If you’re “full SPA”, then you’re replacing links with “data refreshes” + routing. To be honest I feel like Angular captured this notion way better than React and derived FRP models do. At least in terms of still being close to classic web dev

                                                    3. 2

                                                      Where’s the evidence that SPAs add to development complexity?

                                                      “Where is the evidence that SPAs reduce complexity and provide additional capability?” is perhaps a better question, in my mind anyway. I’m not sure this is something easy to see unless you’ve been working industry for over a decade. The state issues are something we worked through with thick-client desktop apps before embracing the simplicity of the web. It wasn’t a fun experience then, so the natural reaction is to only embrace it when you really get bang for your buck.

                                                      I think the author is being curmudgeonly in tone which should be differentiated from other tones which he could have taken. If someone truly evaluates each of the points noted they can develop a better cost/benefit trade-off for their approach approach than without.

                                                      The article isn’t dated. Many of the things written were true in 2011, a year that stands out for me because of an encounter with a particular SPA. The difference between then and today is that we have more experience and better tools for building SPAs. I think it would be interesting to see more elaboration on how SPAs have evolved to handle each of the challenges presented.

                                                    1. 1

                                                      I’m not a big fan of the declare-endpoints-with-decorator approach – maybe someone can help me understand it better? It always rubs me the wrong way that some global application object is being mutated at the top level, which itself gets triggered by import statements. Parameterizing that top level object or instantiating multiple of them (e.g. for tests) then feels really awkward.

                                                      1. 1

                                                        It also makes it a bit weird if you have different functions for each http verbs. It starts to feel messy after a while. At least flask has an “escape hatch” where you can setup the routing in a more manual fashion.

                                                      1. 0

                                                        at least for me, the biggest impact that most engineering teams can have is on the front end, not on the backend

                                                        The caveat is important, because I don’t think that’s true for all places (and I say this as a full-stacker who is more focused on front-end).

                                                        Back-end is certainly moving towards being abstracted away (see Serverless) but I just think that makes being a full-stack dev easier with more time/focus spent on front-end, but I really believe it’s hard to not think about back-end when working on UIs these days

                                                        1. 11

                                                          Back-end is certainly moving towards being abstracted away (see Serverless) but I just think that makes being a full-stack dev easier with more time/focus spent on front-end, but I really believe it’s hard to not think about back-end when working on UIs these days

                                                          I feel like this is something of a false representation of both frontend and backend that’s becoming pretty common. “backend” now means “CRUD interface to a database” to a lot of people, but there’s soooo much more to software than just serving up some webapp. The “backend” to say, a DNA sequencer, or radio telescope, or a CAD system, or tons of other things is never going to be abstracted away in any meaningful sense.

                                                          1. 1

                                                            Agreed, but I will say most articles are referring to front-end/back-end in the context of a web app. I will concede that for systems programming front-end means the UI layer and back-end may mean the DB or business logic layer, which is far more customized than the standard CRUD apps running on a web server.

                                                          2. 7

                                                            Back-end is certainly moving towards being abstracted away (see Serverless)

                                                            Serverless doesn’t abstract the back-end away, though? It just means that you spend less time on infrastructure, but you still have business logic, now it just lives on a function-as-a-service platform rather than in (eg) your node or python application running on an EC2 instance.

                                                            At the same time as that’s happening (I’d argue it’s not really happening that much, I think serverless is a very tiny segment, and not growing all that fast) there’s a move in the opposite direction with GraphQL bringing things that used to be the domain of the back-end code into the front-end code. It’s greatly expanding the scope of the front-end - now you have to understand the structure of your data and write queries (granted, you may not have to understand past the GraphQL server layer) as well as all the other things that go already into a web application. Previously you might have punted a lot of that responsibility to whoever was writing the endpoint you were using.

                                                            1. 1

                                                              Serverless doesn’t abstract the back-end away, though?

                                                              It is abstracting away a lot of the back-end ORM boilerplate in favor of a much simpler function-based API. GraphQL is also a great thing I agree because it is sharing that responsibility with more developers

                                                              1. 1

                                                                I’m really having trouble parsing this. Could you provide an example?

                                                                From my pov serverless, at best, makes backend deployment as easy/hard as frontend deployment (you don’t have to manage the os or install the browser(s) displaying your UI).

                                                          1. 37

                                                            What about dependencies? If you use python or ruby you’re going to have to install them on the server.

                                                            How much of the appeal of containerization can be boiled directly down to Python/Ruby being catastrophically bad at handling deploying an application and all its dependencies together?

                                                            1. 6

                                                              I feel like this is an underrated point: compiling something down to a static binary and just plopping it on a server seems pretty straightforward. The arguments about upgrades and security and whatnot fail for source-based packages anyway (looking at you, npm).

                                                              1. 10

                                                                It doesn’t really need to be a static binary; if you have a self-contained tarball the extra step of tar xzf really isn’t so bad. It just needs to not be the mess of bundler/virtualenv/whatever.

                                                                1. 1

                                                                  mess of bundler/virtualenv/whatever

                                                                  virtualenv though is all about producing a self-contained directory that you can make a tarball of??

                                                                  1. 4

                                                                    Kind of. It has to be untarred to a directory with precisely the same name or it won’t work. And hilariously enough, the --relocatable flag just plain doesn’t work.

                                                                    1. 2

                                                                      The thing that trips me up is that it requires a shell to work. I end up fighting with systemd to “activate” the VirtualEnv because I can’t make source bin/activate work inside a bash -c invocation, or I can’t figure out if it’s in the right working directory, or something seemingly mundane like that.

                                                                      And god forbid I should ever forget to activate it and Pip spews stuff all over my system. Then I have no idea what I can clean up and what’s depended on by something else/managed by dpkg/etc.

                                                                      1. 4

                                                                        No, you don’t need to activate the environment, this is a misconception I also had before. Instead, you can simply call venv/bin/python script.py or venv/bin/pip install foo which is what I’m doing now.

                                                                      2. 1

                                                                        This is only half of the story because you still need a recent/compatible python interpreter on the target server.

                                                                    2. 8

                                                                      This is 90% of what I like about working with golang.

                                                                      1. 1

                                                                        Sorry, I’m a little lost on what you’re saying about source-based packages. Can you expand?

                                                                        1. 2

                                                                          The arguments I’ve seen against static linking are things like you’ll get security updates etc through shared dynamic libs, or that the size will be gigantic because you’re including all your dependencies in the binary, but with node_packages or bundler etc you’ll end up with the exact same thing anyway.

                                                                          Not digging on that mode, just that it has the same downsides of static linking, without the ease of deployment upsides.

                                                                          EDIT: full disclosure I’m a devops newb, and would much prefer software never left my development machine :D

                                                                          1. 3

                                                                            and would much prefer software never left my development machine

                                                                            Oh god that would be great.

                                                                      2. 2

                                                                        It was most of the reason we started using containers at work a couple of years back.

                                                                        1. 2

                                                                          Working with large C++ services (for example in image processing with OpenCV/FFmpeg/…) is also a pain in the ass for dynamic libraries dependencies. Then you start to fight with packages versions and each time you want to upgrade anything you’re in a constant struggle.

                                                                          1. 1

                                                                            FFmpeg

                                                                            And if you’re unlucky and your distro is affected by the libav fiasco, good luck.

                                                                          2. 2

                                                                            Yeah, dependency locking hasn’t been a (popular) thing in the Python world until pipenv, but honestly I never had any problems with… any language package manager.

                                                                            I guess some of the appeal can be boiled down to depending on system-level libraries like imagemagick and whatnot.

                                                                            1. 3

                                                                              Dependency locking really isn’t a sufficient solution. Firstly, you almost certainly don’t want your production machines all going out and grabbing their dependencies from the internet. And second, as soon as you use e.g. a python module with a C extension you need to pull in all sorts of development tooling that can’t even be expressed in the pipfile or whatever it is.

                                                                            2. 1

                                                                              you can add node.js to that list

                                                                              1. 1

                                                                                A Node.js app, including node_modules, can be tarred up locally, transferred to a server, and untarred, and it will generally work fine no matter where you put it (assuming the Node version on the server is close enough to what you’re using locally). Node/npm does what VirtualEnv does, but by default. (Note if you have native modules you’ll need to npm rebuild but that’s pretty easy too… usually.)

                                                                                I will freely admit that npm has other problems, but I think this aspect is actually a strength. Personally I just npm install -g my deployments which is also pretty nice, everything is self-contained except for a symlink in /usr/bin. I can certainly understand not wanting to do that in a more formal production environment but for just my personal server it usually works great.

                                                                              2. 1

                                                                                Absolutely but it’s not just Ruby/Python. Custom RPM/DEB packages are ridiculously obtuse and difficult to build and distribute. fpm is the only tool that makes it possible. Dockerfiles and images are a breeze by comparison.

                                                                              1. 12

                                                                                Debating I started after realising that I sometimes struggled to articulate myself as well as I’d like to during meetings at work, and I thought debating might help me to simultaneously think (i.e. formulate arguments) and speak (i.e. articulate them clearly). It turned out that I love debating; not only does it help train your public speaking skills but since we debate motions about a wide variety of topics, it’s great simply getting a more nuanced view of things that happen in the world. Also, the people are great.

                                                                                Sustainability I spend time reading about, pontificating about, or acting around sustainability. I’m particularly interested in environmental sustainability but also in any system that is ‘unsustainable’ too. I feel a responsibility to try and contribute positively to these kinds of problems (plus it’s fun, if approached with a non-cynical mindset). I try hard to live a holistically sustainable life, not just environmentally, but also socially and politically.

                                                                                Keeping healthy Keeping fit and healthy is a really high priority for me, I usually exercise three times a week, and pick between circuit training, bouldering, running, stretching and strength training. Eating well is also really important to me. I’m not sure if these class as hobbies because I’m not really willing to compromise on them if life gets busy in other areas (so they’re more like essentials), but I do enjoy them :)

                                                                                Reading My favourite genre is fantasy; I love the feeling of becoming immersed in the ‘world’ of a story. Having said that, I’m currently trying to branch out a little, particularly to read books that will give me a different perspective somehow (e.g. classics or books written from an interesting point of view). I’m currently reading The Kite Runner. Book recommendations are welcome :)

                                                                                Gratitude journal Every night, I wrote down things I’m grateful for in a journal. When I first heard about gratitude journals I thought they sounded pretty lame. However, I think it’s really useful to acknowledge that generally, I live in a great time and am incredibly lucky compared to many. Spending ~5 minutes to actively recognise the things that I have in life (as opposed to what I don’t have, i.e. the consumerist view) definitely makes me a happier and more contented person.

                                                                                [Not a hobby] Work I work as a software engineer, and really enjoy it. I don’t think of work as a hobby because I recognise that there’s a contract between myself and my employer, but, a happy side effect of that contract is that I derive enjoyment from a job well done and getting to collaborate with great colleagues.

                                                                                1. 4

                                                                                  I share a lot of these (except debating!). I just heard about gratitude journals, and my brother has started writing one. I’m really interested to see how it works out for him. It does seem to make a lot of sense!

                                                                                  Exercise is so important for my mental state. I play badminton, and for the 2 or so months of the year when it winds down, I can really feel myself getting more stressed and anxious.

                                                                                  And living sustainably, and continually searching for more ways to do so gives my life meaning. I feel like it’s my biggest responsibility, and there are still so many ways to improve. What I love about it is that many of the changes I’ve made have not been about giving up on convenience. In many ways my life is more simple, and it makes more sense. I feel like I’m regaining control over my life!

                                                                                  1. 3

                                                                                    Debating sounds interesting! How do you practice that? Are there clubs or similar?

                                                                                    (I know debating is a quasi-academic activity in the US and maybe other Anglo-Saxon milieus but it’s almost unknown in Sweden outside people who are semi-pro politicians).

                                                                                    1. 4

                                                                                      I do British Parliamentary Debating (BP) at a local club. I just googled ‘debate club [my city]’ and found a great club :)

                                                                                      We debate all kinds of things, motions I can remember include “This house regrets the rise of satire in politics”, “This house, as the government, would subsidise bank loans for poor people” and “This house, as the Chinese government, would give up all terratorial claims to the nine dash line”.

                                                                                      1. 3

                                                                                        Not exactly debating, but you can hone some related skills by doing Improv theatre, and to my understanding you can find lots of meetups and clubs everywhere.

                                                                                      2. 2

                                                                                        Got any good book recommendations? I started reading more fantasy recently and am always on the lookout for new stuff.

                                                                                        1. 2

                                                                                          For Fantasy: Malazan Book of the Fallen series is very good Also I quite liked Joe Abercrombie’s The First Law Trilogy

                                                                                          1. 2

                                                                                            I love Brandon Sanderson; I’d recommend any of his series really :)

                                                                                        1. 1

                                                                                          I like it! But I share the dismay of others that it’s (maybe unsurprisingly) not the most interesting content.

                                                                                          On a related note, at my previous workplace we had an internal website that scored and ranked all the videos that were going through our API – since it was an embedding API, we had a really good window into what people were sharing and watching. It was really great for discovering new content; I still miss it and have always been kind of sad that we never productized it. The punchline being, if you can find a way to get an interesting cross-section of content, it would be a really cool product.

                                                                                          1. 2

                                                                                            I haven’t given hours for probably a decade. Since then I’ve been at companies where, as a team, we only need to provide story estimation points in a Fibonacci range. I think this is pretty normal practice for development teams following the agile/scrum methods.

                                                                                            I suppose internally this is all converted to hours by managers looking at the team’s velocity although I’m not sure and thankfully I never have to worry about it.

                                                                                            1. 8

                                                                                              Man, everyone uses fibonacci numbers for estimation but it seems really weird to me – in practice it just means anything but 4.

                                                                                              1. 3

                                                                                                Most software developers are too lazy to actually learn how to estimate what they’re doing. Everybody else in every other field (new or old) is perfectly capable of estimating how long work will take, what it will cost, and how much they’ll get done each week. But software developers apparently can’t, or more realistically, they refuse to do so. I don’t know why software developers think they’re super special, but they do.

                                                                                                They can’t be bothered, so they invent ever more fanciful ways of refusing to give proper estimates. The current trend is that they’ll give it in ‘story points’ in some pseudo-mathematical scale that sounds fancy (Fibonacci numbers) but is in fact completely meaningless in the context of estimates, and then claim that you can’t do arithmetic on them.

                                                                                                Reality is of course that people hate being measured. And because people think software developers are all very smart, they trust developers when they say things like ‘you can’t add these estimates to get the amount of work you should expect me to do each week then hold me to it’. Of course they can. They’re time estimates. If they weren’t estimating how long things took they’d be completely and utterly useless and nobody would bother doing them in the first place.

                                                                                                I don’t really know what software developers expect. ‘Assign me a task and I’ll let you know when it’s done’. ‘Roughly when will that be?’ ‘You can’t estimate software development timelines’. Except you obviously can. Nobody expects estimates to be exact, but they shouldn’t be that hard. Everyone else in the world is capable of estimating how long things take.

                                                                                                1. 2

                                                                                                  I think the issue is that “You can’t estimate software,” has been repeated so many times that people take it as a truism. Kind of like, “Premature optimization is the root of all evil” and all the pain that has caused. Yes, estimating software is hard, to a point – large scale projects with many team members are hard to estimate in the same way that it is in other engineering disciplines. But if the work item is adding a column to your crappy web app’s database? Not so much.

                                                                                                2. 1

                                                                                                  My team’s been using Fibonacci estimates but I don’t really think it makes much sense, though in practice it somehow works. For example four 2-point stories rarely take as long as one 8-point story. So what’s the point in measuring the total points that a team accomplishes at the end of one sprint? Maybe our estimate errors add up in a way that cancels the noise.

                                                                                                  1. 2

                                                                                                    They’re T-shirt sizes (large, medium, small) that you can do arithmetic on. I’m not aware of a better justification than that. (Though if you ask me, being able to do arithmetic on your estimates is a serious downside…)

                                                                                              1. 3

                                                                                                Yeah, it’s pretty frustrating that software has seemingly gotten as wasteful as it has. I think this is a consequence of the power of abstraction – we’re building on the shoulders of giants on the shoulders of giants. That silky smooth text editor on a 286 was essentially 100% bespoke, with every line of code contributing. Now our text editors are built with GUI toolkits and powerful, yet general purpose edit controls…so we drag in all sorts of stuff that we don’t need. This is the sacrifice we make at the altar of code reuse.

                                                                                                Whether or not this is a good thing is up for debate. But I think it’s unavoidable with the particular combination of software demand, economies of scale in hardware, and labor pool that we have in this world we’re stuck with.

                                                                                                1. 3

                                                                                                  It sounds like the challenge going forward is collapsing these towers of dependencies. Like the Zen of Python says:

                                                                                                  Flat is better than nested.

                                                                                                  1. 1

                                                                                                    There are different scales of tradeoff in code reuse, though. Very often, using some third-party library takes more effort than implementing the facilities you were going to use with builtin facilities (particularly if you’re working in a language with a feature-rich standard library, like python) – and this problem gets worse the more bloated the library is. We buy into some framework because of flashy features we will never use, then waste a lot of time learning the framework’s special ways of doing things, and in the end the code we wrote is unportable and the sunk cost fallacy keeps us from doing the sensible thing & throwing it out.

                                                                                                    The most irritating thing, for me, is that good-enough performance isn’t very hard for most common tasks & doesn’t require any special knowledge. If you write something in python and you do it in the most straightforward way possible, with no particular emphasis on optimization, it’s still going to be hard to make it too slow (the example in the post about a python command line script running for 1.5 seconds is sort of absurd, unless it’s doing a bunch of complex math without the help of numpy). Even so, basically everything we use – including most common open source applications – are substantially slower than the minimum acceptable performance, for no clear & defensible reason.

                                                                                                    You can make a milky-smooth text editor in about three lines of python – Tk ships with a fast & powerful text widget that does about 90% of what you want from a rich text editor. In other words, it’s literally easier to make it fast than to make it slow, so long as you are willing to avoid being sucked into dumping cycles into unnecessary facilities.

                                                                                                    1. 1

                                                                                                      Bouncing off of your statement about text editors, I suggest you check out Kakoune, it’s a modal code editor that packs a punch.

                                                                                                    1. 6

                                                                                                      Holy misleading axes. The post-warmup improvements look impressive and significant until you realize that the range is chosen to make it look so. The LuaJIT improvement is about 7 milliseconds, or around 1.2%. The other improvements are on a similar scale.

                                                                                                      I don’t think these orders-of-magnitudes even come close to supporting the thesis of the article.

                                                                                                      1. 4

                                                                                                        I don’t think this is entirely fair - yes, the differences are not dramatic, but as the article says “We fairly frequently see performance get 5% or more worse over time in a single process execution. 5% might not sound like much, but it’s a huge figure when you consider that many VM optimisations aim to speed things up by 1% at most. It means that many optimisations that VM developers have slaved away on may have been incorrectly judged to speed things up or slow things down, because the optimisation is well within the variance that VMs exhibit.”

                                                                                                        1. 5

                                                                                                          I might be a bit more generous if the article would call out the actual differences, rather than just point at misleading graphs – seriously, with an honest y axis it’d be hard to even notice it.

                                                                                                          Regardless, while a 5% improvement is not trivial, it is trivial in the context of the article, which is people complaining about slow VMs. That’s in the noise as far as general programming language performance goes.

                                                                                                      1. 1

                                                                                                        Looks great! But I don’t understand the rationale behind not allowing genericity on struct methods. Why is that case any more complicated than on normal functions, which they say this proposal will support?

                                                                                                        1. 3

                                                                                                          I think it is due to reflection and their “dual-implementation” constraint. In Go you can query any type for number of methods (and iterate over them) using reflect.Type. It would be impossible to implement reflect.Type.Method* family of methods for public type using static generics implementation strategy. When compiling package you have no way to know how many different methods type will have in final executable.

                                                                                                          1. 1

                                                                                                            Ah, I see. Seems like an odd concession to make – I would think the utility of generic methods would outweigh the use of reflection. Also, what would have happened if generic functions were also at odds with the reflection API? Would that have torpedoed the whole thing?

                                                                                                            1. 2

                                                                                                              Go has a philosophy of only adding orthogonal features.

                                                                                                              They aren’t willing to have ‘reflection works except on generic methods’, and they aren’t going to break backwards compatibility on reflection.

                                                                                                              1. 2

                                                                                                                Well sure, but now they’ll have ‘generics work except on methods.’ As annoying as it seems I respect the unwillingness to break backwards compatibility, though.

                                                                                                              2. 1

                                                                                                                They want to maintain compatibility with Go1 which means that all the old APIs should still produce correct results.

                                                                                                          1. 6

                                                                                                            I really, really want to like Nim but there are just too many oddities for me to seriously dig in. The biggest one is probably the story for writing tests: given its import and visibility rules, it’s really awkward to test functions that aren’t explicitly exported. The official position is, “don’t test those functions,” which I find somewhat naive.

                                                                                                            The standard library is a bit unwieldy, but maybe it’s just a maturity issue. For instance, the “futures”-like system for threads, processes and coroutine style processing are all incompatible. What?

                                                                                                            Finally, (and maybe this is just taste), but there’s heavy use of macros everywhere. The nim web server (jester), for instance, is heavily macro-ized which means error messages are odd and pretty severely affects composability.

                                                                                                            1. 4

                                                                                                              Don’t forget the partial case sensitivity. “Let’s solve camelCase vs snake_case by allowing you to write any identifier in either, at any time! Yay!”

                                                                                                              1. 2

                                                                                                                it’s really awkward to test functions that aren’t explicitly exported. The official position is, “don’t test those functions,” which I find somewhat naive.

                                                                                                                I don’t know if that’s the official position, but you can test internal functions in the module itself in the when isMainModule: block. Here’s an example.

                                                                                                                1. 3

                                                                                                                  You can also include the module and test it that way. So there are definitely ways to do it. I don’t think there are any official positions on this.

                                                                                                                  1. 1

                                                                                                                    Hmm, I seem to remember include getting kind of messy on larger code bases – wish I could be more specific, it was a while ago. By official position I meant the responses by the developers on the Nim forum, so maybe that was a bit heavy handed.

                                                                                                              1. 13

                                                                                                                There’s a quote I like that I can’t remember from where:

                                                                                                                Thirty years ago “it reduces to 3SAT” meant the problem was impossible. Now it means the problem is trivial.

                                                                                                                1. 2

                                                                                                                  I wrote something vaguely like that a few years ago, though I’m sure I wasn’t the first to observe it:

                                                                                                                  SAT, the very first problem to be proven NP-complete, is now frequently used in AI as an almost canonical example of a fast problem

                                                                                                                  1. 1

                                                                                                                    Why is that? Because computers are much faster, or better algorithms?

                                                                                                                    1. 3

                                                                                                                      We have faster hardware and better algorithms now, yes. But the real reason is because early theoretical results which emphasized worse-case performance had scared the entire field off even trying. These results based on complexity classes are true, but misleading: as it turns out, the “average” SAT instance for many real-world problems probably is solvable. Only when this was recognized could we make progress on efficient SAT algorithms. Beware sound theories mis-applied!

                                                                                                                  1. 2

                                                                                                                    Cool, I’m surprised a SAT solver can do a sodoku puzzle in just a millisecond or so. It’s got to be what, a couple thousand clauses? I guess it all collapses pretty quickly after a couple values slot in.

                                                                                                                    1. 4

                                                                                                                      yeah one of the nice things about SAT solving is the efficient propagation of information: once one clause is solved it quickly updates all the clauses that were blocked by not knowing that.

                                                                                                                    1. 2

                                                                                                                      I wrote a fast cat once out of actual necessity.

                                                                                                                      I was working with an embedded system where, for installation/testing purposes (details forgotten), we had a service running in a VM that would help bootstrap a system. Part of this setup was a script that would run on the target, read a binary blob from a file descriptor and write it to the device. That reading was done with the target system’s implementation of cat.

                                                                                                                      As it happened, the sending of the binary blob to the target turned out to be a significant bottleneck. After I profiled it, it turned out that cat was taking a long time to read and write the bytes. I looked at the source and found it was using fread and fwrite. I changed it to use read/write and the transfer time went down significantly. It was great because I’m fairly certain this was part of our automated build system to create images for the devs and the result was that build times went down a lot.

                                                                                                                      So sometimes you really do need a faster cat.

                                                                                                                      1. 2

                                                                                                                        Why were fread/fwrite slow? Aren’t they thin veneers over read/write that do a bit of buffering?

                                                                                                                        1. 2

                                                                                                                          For “buffering”, read “copying”.

                                                                                                                          With read/write, it’s just copying into a buffer (read), and then copying out of that buffer (write).

                                                                                                                          With fread/fwrite it’s copying into a buffer (read), then copying from that buffer to another buffer (fread), then potentially copying that back (fwrite), before finally copying it back into another buffer (write). That can really add up - even the read/write loop is more than we’d want ideally, hence stuff like splice.

                                                                                                                      1. 2

                                                                                                                        After reading the story here on solving snakebird levels I’ve convinced myself that it isn’t as hard as the author seems to think. So I’m going to give that a go and be proven wrong, I’m sure.

                                                                                                                        1. 12

                                                                                                                          Say what you will about the Ruby community, but I’ve never seen them fly into a moral panic over a tiny syntax improvement to an inelegant and semi-common construct.

                                                                                                                          The person-years and energy spent bikeshedding PEP 572 are just astoundingly silly.

                                                                                                                          1. 7

                                                                                                                            Say what you will about the Ruby community, but I’ve never seen them fly into a moral panic over a tiny syntax improvement to an inelegant and semi-common construct.

                                                                                                                            Try suggesting someone use “folks” instead of “guys” sometime…

                                                                                                                            1. 13

                                                                                                                              I switched to folks and do you know how satisfying of a word it is to say? “Hey folks? How’s it going folks? Listen up folks!” I love it.

                                                                                                                              On the other hand the interns weren’t too keen on “kiddos.”

                                                                                                                              1. 6

                                                                                                                                I’ve gotten used to saying “’sup, nerds” or “what are you nerds up to?”

                                                                                                                                1. 5

                                                                                                                                  A man/woman (or nerd, I guess) after my own heart! This has been my go-to for a while, until one time I walked into my wife’s work (a local CPA / tax service) and said, “What up, nerds?” It didn’t go over so well and apparently I offended some people – I guess “nerd” isn’t so endearing outside of tech?

                                                                                                                                  Thankfully, I don’t think I learned anything from the encounter.

                                                                                                                                  1. 3

                                                                                                                                    It’s not endearing within tech to anyone over 40.

                                                                                                                                    1. 2

                                                                                                                                      I generally only use it in a technical setting – so within my CS friend group from college, other programmers at work, etc… whenever it’s clear that yes, I am definitely not trying to insult people because I too am a nerd.

                                                                                                                              2. 1

                                                                                                                                as @lmm notes above, a minimalist, consistent syntax is an important part of python’s value proposition. in ruby’s case, adding syntactic improvements is aligned with their value proposition of expressiveness and “programmer joy”, so it’s far less controversial to do something like this.

                                                                                                                              1. 2

                                                                                                                                Looks like it’s being developed in Rust now? So from javascript to C++ to Rust?

                                                                                                                                1. 1

                                                                                                                                  From what I understood, it was started in JS but was more about testing out various prototypes and c++ was pretty quickly abandoned in favor of rust when he switched from javascript. The devblog has very detailed explanations of his process: http://cityboundsim.com/devblog