1. 4

    I’m a bit confused about the date thing. My Mac has the date and time in the menu bar on the right.

    1. 1

      Dato can show more information like the calendar and multiple time zones.

    1. 2
      • et-see - initially used to call it ee-tee-see till i heard someone pronounce it et-see
      • lib - like lib[erty]
      • char - like char[acter], called it char[coal] till someone made pointed out it was wrong (it wasn’t wrong but the person was not comfortable with the idea that there can be different pronunciations)
      • f-es-see-k
      • skema

      i taught myself to code and had different pronunciations in my head which changed as i was exposed to other people who also wrote code and used linux.

      1. 2

        It is said that people who pronounce things “wrong” should be respected because they learned it from a book (or now the Internet) rather than being taught in person :)

      1. 7

        Setting up my personal software (daemons and bots) for raspberry pi. They are mostly written in Go so it should in theory be as simple as recompiling. And traveling for the rest of the weekend.

        1. 3

          I am setting up a build environment for AWS CloudFormation/Lambda applications in VS Code. I’ve worked on all the pieces separately. I think I grok them enough to assemble it all together into a code-build-test-deploy project.

          I’m starting off with a triple-language lambda – code that does the same thing in Python, C#, and F#. The cloud I set up should call this code on a regular basis. It will poll a website for changes using a RESTFUL API. If it finds any, it’ll grab the new information and put it in a publicly-accessible S3 bucket.

          I was going to add Route 53 and CloudFront stuff to the build, but I’ve already developed some stuff using that for my first CF stack.

          I want to say it’s tough, but it’s not. However it’s going quite slowly. I think the reason is that while I know a lot about the separate pieces, trying to assemble them into a AWS Cloud Architect-y kinda workflow is quite painful. There are a zillion little loosely coupled pieces all over the place. And aside from basic ATDD poking around, I’m not really sure what it means to test a cloud architecture.

          There’s a lot of stuff to learn and I’m having fun. That’s the important part.

          1. 1

            I believe CloudFormation will allow you do have CI as part of a deployment for your lambda functions if you change your workflow so the repo’s on AWS. Testing AWS offerings like lambda is a sort of vendor lock in because there’s really no way to do it any other way.

            1. 1

              You are correct – and you may be anticipating where I’m going with this.

              I’ve been writing what I consider to be “true” microservices for many years now: small, pure functional apps that run from the command line. By default they use streams, but any data sync should be fine for them. I don’t use a bus; instead I use various OS features for glue and overall testing.

              In this environment, lambda really isn’t that big of a deal. I’m getting data via JSON instead of streams. There may be some event/interface work I need to do. That’s part of what I’m figuring out. I know AWS will keep an instance warm for a bit even if you’re not using it, so I need to think about setup vs. processing. Still, I think it’s going to be trivial.

              I agree with the vendor lock-in concern. I think you can do it without that problem as long as you carefully pack your own picnic box. That is, functions with data streaming in and out that your programmatically join is one thing. Integrating you coding and CI/CD process with your cloud vendor is another thing entirely.

              There’s the ever-prevalent “video game” danger with AWS: lots of pretty screens with easy to click-and-deploy cool-stuff. I love the ease-of-use part, and I love the offerings. The danger is that you have to be aware of the linkages to Amazon you’re creating. Best keep everything as code, everything in your own repo (GitHub for me), and view where the stuff runs as plug-and-play.

              This, of course, means honking around with all the little details involved with coding, pipelines, and clouds. That sucks, but I’m okay with that. Great way to actually learn stuff instead of just poking around until it works.

              1. 2

                I’ve been working on a similar stack, to avoid any vendor lock it i have started using the LambdaProxy project and now i have a ‘local’ binary which runs a plain http server and is very useful for debugging.

                I am also going to look into CDK because writing json/yaml for cloudformation isn’t what i want spend my time one.

                1. 1

                  My belief is that a parameterized CF stack should work for a bunch of stuff. I already have one for static websites. I’m developing this lambda one. There are probably 3 or 4 others and then I’m done. The entire point is not to rely heavily on AWS, so at some point the more I’m doing CF/Lambda stuff the more I’m headed down the wrong road.

                  Once you’ve got deployment and execution in, the rest of it is just replicating continuation stuff, right? Sequencing, map-reduce, orchestration – maybe a couple of others. At that point I think you finish up the work with a bit of containerization and K8 scripting.

                  As an industry, we’re really not that far from true vendor/platform/OS/language-agnostic coding, where we only pay for storage and CPU cycles, ideally at market rates. We’re very, very close.

          1. 8

            HN comments

            the author commented on HN about the attempts made previously before settling.

            1. 3

              I also recommend reading HN version of articles like this since you’ll see a lot of projects or implementation techniques pop up in the discussions. Especially on interpreters or compilers.

              1. 1

                How about we have a threaded story reader that can pull (and rank/rate) comments from multiple sources. If posted to a small enough subreddit, even the reddit comments could have content.

              2. 3

                Yep they had done some work with go, Lua before they settled down to rust

              1. 4

                Java was excluded from consideration because of the requirement of deploying the JVM and associated libraries along with any program to their production servers.

                Haha, what a load of crap, just admit you don’t like java. We should be honest about these things.

                1. 34

                  Please don’t dismiss people by telling them you know their own opinions better than they do or that they’re lying. There’s much better ways to disagree with their decision here.

                  1. 8

                    It’s a case study for promoting Rust…I wouldn’t judge it the same as dismissing somebody’s own blog post or whatever, say.

                    1. 3

                      It’s dismissing people’s experience. The medium is irrelevant.

                      1. 21

                        Sometimes people’s experiences are not representative of reality, and sometimes people lie about their experiences, and sometimes people rewrite their experiences without realizing it, and sometimes people have experiences so limited that their ability to usefully generalize and advise others is called into question.

                        Just because it’s somebody’s claimed experience doesn’t magically make it somehow unable to be questioned.

                        And so we’re on the same page…we’re not talking about somebody relating a background of trauma or something: we’re talking about a company (npm) engineering team deciding to redo the same task three times using 1 hour (Node), 2 days (Go), and a week (Rust) and then the RESF using that to shill Rust (glossing over a doubling in the complexity of the npm’s language ecosystem and stack.

                        If they’d provided real performance numbers, maybe shown how the Rust version vastly outperformed the Node version, then this might be a better article. As it is, anybody with experience reading press releases (rightly) will wonder if the “experiences” are worth learning from.

                        1. 3

                          What exact claim do you find insufficiently backed up? They literally just documented the (their!) process of rewriting a chunk of JS in a different language, and how it went (for them). To get back to the original “page”: The “claim” ac was attacking was an opinion, a non-falsifiable statement at worst (as I think the conclusion is).

                          1. 17

                            There are no numerical metrics or benchmarks in the article. The service in question was “projected to become a CPU-bound task”, but it’s unclear if that’s a real issue without seeing their math. Other quotes like “the legacy JavaScript implementation of this service in Node.js was in need of a rewrite in any case” hint that this might be a strictly unnecessary rewrite.

                            Have you not experienced engineers selling a rewrite or new technology because they’re bored and not because it’s necessary?

                            1. -5

                              Ugh. Nobody is selling you anything here.

                              1. 13

                                “Rust Case Study:” “Copyright © 2019 The Rust Project Developers” “https://www.rust-lang.org

                                It’s on there specifically to convince people to adopt Rust. Which is fine: they’re promoting their work and how others benefit from it on their project page. (shrugs) It doesn’t bother me as much as friendlysock since I got at least two things out of it:

                                (a) Javascript developers were able to adopt it. That’s good to know in long term since I’m for minimizing Javascript use in general. Rust apps will also be more secure and maybe predictable. The typical predictions so far were that it would win over only C and C++ types, not Javascript and Go. This is a data point against that expectation for Javascript in an unlikely place.

                                (b) The Rust apps caused less problems, possibly due to what I just said. Then again, it could be anything since we have no data. Might not even be Rust. Heck, the Go rewrite might have taught them some lesson they reused when making the Rust version. We don’t know.

                                Now, far as a scientific evaluation, there’s nothing more to go on as friendlysock says. They didn’t even give us numbers. We’d also be interested in what was easy, difficult, and so on at a language level for the work they were doing. What they told us was what everyone writes, including Rust project’s marketing pages. It objectively introduces no new information on a technical level that we can evaluate or build on.

                                1. 2

                                  We’d also be interested in what was easy, difficult, and so on at a language level for the work they were doing.

                                  The did mention that the Rust implementation was more difficult, though.

                                  “Therewriteof the authorization service using Node.js tookabout an hour. … The Go rewritetook two days. … The rewrite of the service in Rust did take longer than both the JavaScript version and the Go version: about a week to get up to speed in the language and implement the program. Rust felt like a more difficult programming language to grapple with.”

                                  1. 2

                                    Almost all things on Rust mention a learning curve with borrow-checker (or language), cargo being great, and a great community. Mentioning that downside is echoing common claims more than anything extra critical at this point. It’s part of the refrain.

                                    You mentioning this did bring another data point I overlooked: they felt up to speed in Rust in about a week. So, Javascript developers both found the language useful and picked it up in a week. Or at least did for that one type of service well enough to falsely think they understood it in general. See how we’re still lacking objective data? We have a nice anecdote, though, which justifies trying to train a crowd of JS developers on Rust on similar or different projects to see what happens.

                                    1. 1

                                      See how we’re still lacking objective data?

                                      That’s not a surprise to me, since I believe that the programming language field is at least a century away from having the capability of gaining objective data on anything non-trivial. We’re like surgeons ridiculing the guy who washes his hands before operating.

                                      I guess that guy is Rust.

                                      1. 3

                                        It’s a frequent complaint we have. We’d love to have more data to compare us to.

                                2. 6

                                  Nobody is selling you anything

                                  Companies don’t just publish information randomly. A white paper is a standard marketing device (https://en.wikipedia.org/wiki/White_paper#In_business-to-business_marketing).

                                  In this case they’re selling:

                                  1. NPM as a rigorous engineering culture (recruiting), and
                                  2. JavaScript-Rust ecosystem cohesion (technology)
                                  1. 3

                                    Exactly, we use whitepapers in precisely this fashion. They are basically executive tl;drs and as such gloss over details.

                      2. 2

                        Did you really need use Sysop hat to say that?

                        1. 3

                          hatters gonna hat.

                        2. 0

                          Perhaps the ‘haha’ didn’t convey my tone right. I meant it as a jab/joke, the type of thing you would say to make fun of your friend…

                          ‘cmmmoooon, my friend… just admit it, you don’t like java … nenornenornenor … lets go play tag’

                          1. 0

                            Also, I didn’t say lying… I think I was more implying a level of self delusion.

                          2. 19

                            Those are valid complaints. Deploying a Java service requires deploying at minimum 2 things that must be kept in sync. A JVM and a Java jar.

                            Because they are separate they bring a number of deployment and operations issues for the life of the service. Rust being a single binary removes those issues entirely.

                            There are resolutions for all those in Java too but they all require more effort than Rust does.

                            1. 12

                              Of all the other things you have to do to run or build service - that seems like a drop in the bucket of things to care about to me.

                              How many backwards incompatible changes are the JVM’s making these days anyway?

                              1. 14

                                Quite a few, actually.

                                I am no JVM expert but in my experience as a Clojure application developer it’s quite common for new Java releases to break Clojure and/or widely-used Clojure libraries. It’s happened several times in the last year. At work, we are currently on an older Java release for this reason. Right now, the latest Java has a serious performance regression for some fairly-common Clojure use cases and folks are being advised not to upgrade.

                                1. 2

                                  that does sound pretty lame.

                                2. 3

                                  It’s not so much the JVM’s backward incompatibilities as the JAR’s that are dependent on the latest and greatest JVM, except that one old JAR that only works on some old ancient version.

                                  So you end up running multiple JVM’s across various machines, to make various JAR’s happy. Suddenly you start day dreaming of rust or go built binaries…

                                  But generally I agree, JVM nightmares aren’t that miserable compared to 5,000 external service dependencies you may have to operate just to make X work.

                                3. 3

                                  Shouldn’t that be easily automated, either provision the server with a pre-installed JVM (using ansible? etc.) or use Docker and put the JVM in there as is common?

                                  1. 1

                                    The most future proof method is to use a Docker container.

                                  2. 4

                                    They’re already doing the exact same thing with Node and the JS code that it runs.

                                    1. 5

                                      Sure, but that’s no reason to go through the same pain a second time. I put up with many things in the Python packaging world because I already know and use Python, but I am not willing to invest time in learning an ecosystem that exhibits issues anywhere close to that.

                                    2. 2

                                      But deploying any service is already tracking versions of databases, the state of your app, the code + compatibility with the OS. I don’t think avoiding java solves dependency or state management.

                                    3. 8

                                      While I think you phrased this strongly, I’m also puzzled by the quote. The legacy application being replaced is a node app. Running a node app requires a VM and standard library just as running a JVM app does. What is the overhead that makes a JVM app unacceptable while a node app is ok? Perhaps it’s language/tooling familiarity? In my experience, all those three-letter J** acronyms can get fairly confusing.

                                      As an aside, I found the following quote refreshingly honest -

                                      “I wouldn’t trust myself to write a C++ HTTP application and expose it to the web”

                                      1. 7

                                        Maybe you haven’t read the full article? it literally says

                                        Given the criteria that the programming language chosen should be:

                                        ● Memory safe

                                        ● Compile to a standalone and easily deployable binary

                                        ● Consistently outperform JavaScript

                                        of which Java doesn’t fulfill at least one.

                                        1. 1

                                          @ac’s comment doesn’t indicate that he missed that part of the article. He is challenging the premise of the second bullet point. The statement about Java that he quoted was the implicit justification for that bullet point.

                                          1. 1

                                            I don’t agree, I think the bullet point was the justification for the statement about Java and not the other way around. At least logically this makes more sense. You do have a point though about the order in the document:)

                                          2. 1

                                            Pretty sure graal vm java does all of those.

                                            1. 3

                                              It’s also commercially licensed by Oracle.

                                              1. 1

                                                from http://www.graalvm.org/downloads/

                                                License

                                                All open-source

                                                Free for production use

                                                1. 2

                                                  The community edition. Enterprise edition:

                                                  • Free for evaluation and other non-production uses
                                                  • Improved performance and smaller footprint
                                                  • Sandboxing capabilities for native code
                                                  1. 1

                                                    Twitter runs on the community edition for all production services and have impressive numbers. Search for talks by Chris Thalinger on YouTube to learn more.

                                                    1. 1

                                                      Yep, it’s still not “it’s free”, but “it has free variant”. Oracle is no stranger to changing the licensing, as they have recently shown with the mainline oracle JVM.

                                                      Not wanting to deal with oracle stuff at all is a reasonable stance.

                                              2. 1

                                                Fair enough, though in this same vein you could argue that C++ is a safe programming language, if you avoid the “thorns”;)

                                            2. 4

                                              It’s a real issue. I stumbled across this “warp” project that makes standalone app bundles for the Buck build system and Buckaroo package manager, which are written in Java.

                                              https://github.com/dgiagio/warp

                                              If it weren’t an issue, then they wouldn’t have done this weird dance. I also took care to make a Python app bundle for Oil for related reasons.

                                              1. 2

                                                I found warp the same way you did :)

                                                but buckaroo is now written in F#

                                                1. 3

                                                  We still use Warp, even though Buckaroo is now AOT-compiled F#. The reason is that we have dynamic libraries but still want users to be able to wget the tool for quick installs.

                                              2. 4

                                                It’s a legitimate concern. Having the ability to deploy a single binary easily from CI or the like can greatly reduce ops headaches (Python is a bit of a mess to deploy because it’s hard to do this).

                                              1. 4

                                                I am not sure that it is possible to prove that the language is total (at least, I know that I don’t have enough knowledge to attempt it), but it is a crucial property the language should possess.

                                                Yes it absolutely is possible.

                                                When applied to programming languages, word “total” means that program written in such a language should provably terminate.

                                                I like to focus on “productivity” instead of “termination” - it’d be possible to write an exponential program which terminates after I die - but it’d have to be DOING SOMETHING.

                                                1. 1

                                                  Yes it absolutely is possible.

                                                  Can you recommend some topics to read about it?

                                                  1. 2

                                                    One important property (the most important?) in this space is ‘strong normalization’. If a language is strongly normalizing then well-typed terms will reduce to a normal form in a finite number of steps. You can formulate and prove this property in a proof assistant.

                                                    Check out Software foundations if you’re interested in being able to do that.

                                                    1. 1

                                                      Thanks!

                                                1. 3

                                                  The last time I looked at Buckaroo it was written in java and now it is in F#.

                                                  I found the pull request but didn’t find anything describing why.

                                                  Does anyone here know?

                                                  1. 6

                                                    Sure I can weigh in. Java lacked the language constructs (namely do-notation, record syntax, type inference) to implement the advanced features found in Buckaroo 2. Rewriting everything is never desirable, but in this case I think it paid off. Buckaroo 2 has more features than 1.x, but also fewer lines of code. This will allow us to release at a faster cadence and also bugs are less likely (less code to review).

                                                    .NET Core was another benefit. Using the AoT compiler it was quite easy to eliminate external dependencies (before the JVM was a pain).

                                                    1. 1

                                                      thanks for the response!

                                                      1. 3

                                                        No problem! Official response is here: https://github.com/LoopPerfect/buckaroo/wiki/FAQ#why-f

                                                  1. 6

                                                    In my opinion the engineering aspects of OOP vs FP are superficial because objects are a poor person’s closures and closures are a poor person’s objects.

                                                    I think the main distinction between the paradigms is the direct line to theory from the FP paradigm. Functional programs are more closely related to mathematical proofs because of the Curry-Howard-Lambek isomorphism. OOP programs on the other hand have a much less direct link back to logic and lambda calculus.

                                                    1. 4

                                                      I think the main distinction between the paradigms is the direct line to theory from the FP paradigm. Functional programs are more closely related to mathematical proofs because of the Curry-Howard-Lambek isomorphism.

                                                      Statically typed functional programmes are, but nothing irritates me much more than people conflating ‘functional programming’ with ‘ML and its derivatives’. There’s much more to functional programming than Haskell. Lisps are functional programming languages, heck any language with first class functions and anonymous functions is technically a functional programming language! Functional programming as a paradigm is done in lots of languages, statically typed or not, strongly typed or not, intended to be used that way from the beginning or tacked on later.

                                                      I also think that this correspondence, while certainly very interesting, is mentioned much more often than it should be. For the average programmer writing average code, I’m not sure it has any relevance at all. To state that it’s the main distinction between the paradigms seems absurd. Surely the main distinction between the paradigms is their attitudes towards mutable state.

                                                      1. 3

                                                        OOP programs on the other hand have a much less direct link back to logic and lambda calculus.

                                                        True, but for a lot of people “tell THING to do ACTION” is more intuitive. One could argue that, while FP is closer to “pure computational formalisms”, OOP is closer to “human cognition.”

                                                        (I am not a cognitive scientist, I didn’t even stay in a Holiday Inn Express last night, but I’ve seen similar arguments before from more knowledgeable people.)

                                                        1. 3

                                                          If object-oriented programming actually involved ‘tell thing to do action’ then that would probably be true. But in practice it doesn’t look like the idealised ‘send message to actor’ kind of OOP, does it? Instead it’s things like ‘tell the string to upper-case itself’ and ‘tell the number to compare itself to this other number’. It just doesn’t really make much conceptual sense to talk about ‘telling objects to do some action’ in real world OOP programming.

                                                          Really I’m not even sure if ‘OOP’ and ‘FP’ are really even a meaningful distinction to be making. I certainly don’t think they’re sliding ends of a different scale, or perfectly diametric opposites. They are both syntheses of a wide array of decisions about how to write computer programmes, and it’s certainly possible to make different sets of decisions than ‘FP’ and ‘OOP’. What each term even means seems to be somewhat disputed: a lot of people now use ‘FP’ to mean ‘statically typed functional programming with immutable state’ and ‘OOP’ to mean ‘anything with inheritance’.

                                                          For example, take ‘normal’ OOP but never mutate the states of objects. Is this now FP? No, objects are still bundles of data and state, so it’s still OOP, but is it even a dichotomy? Some would say Java is OOP so it isn’t FP by definition, but I would say that it has lambdas now, so it is actually just another FP language, and the creators and advocates of Lisp were right: eventually, everyone would have closures.

                                                          1. 1

                                                            I didn’t even stay in a Holiday Inn Express last night

                                                            some context please?

                                                            1. 7

                                                              It was a silly joke. There was an advertising campaign in the United States for the Holiday Inn Express chain of hotels. In the commercials, a problem would occur, a bystander would say “is anyone here a doctor/lawyer/engineer/whatever?!” and someone else would respond “no, but I did stay in a Holiday Inn Express last night!”

                                                              …I didn’t say it was a funny joke.

                                                              1. 1

                                                                thanks!

                                                            2. 1

                                                              Right up until you need a gerund, aka a word ending in “ing”.

                                                          1. 4

                                                            I have to work on Saturday but I still have some things planned for this weekend:

                                                            • I bought a kobo clara HD and started to read my first book on it, it’s about golang. I would like to just get an ‘hello world’, something that will write to a file and something that will fetch the json of a url and ‘parse’ it. To be completely honest I have no idea if this is highly optimistic or not, but we’ll see.
                                                            • I went to Redhat’s Ansible Automates tour and decided I should stop maintaining my own playbooks. I did multiple tests during evenings this week and I like what I see. I also discovered a bug in ansible 2.5 or 2.6 was fixed and that allows me to dynamically include roles from a yaml I include on the fly. Still need to finetune more but it’s looking ok
                                                            • buying Christmas presents is also high on my list for this weekend, I hope to really finish that one.
                                                            1. 4

                                                              Go is not a great language for processing JSON. I have been banging my head against it for years. It might not be a great starting place.

                                                              1. 3

                                                                hmm, i was under the impression that Go is pretty good for processing JSON. Can you provide some examples?

                                                                I haven’t used Go in production yet but was going to use it for my next project, this might change things.

                                                                1. 5

                                                                  Here’s some production example I have which is parsing Prometheus metrics return:

                                                                          metricsMap := make(map[string]interface{})
                                                                          if err := json.Unmarshal(body, &metricsMap); err != nil {
                                                                                  return nil, err
                                                                          }
                                                                  
                                                                          retMap := []map[string]interface{}{}
                                                                  
                                                                          metrics := metricsMap["data"].(map[string]interface{})["result"].([]interface{})
                                                                          if len(metrics) == 0 {
                                                                                  return &retMap, nil
                                                                          }
                                                                  
                                                                          for _, m := range metrics {
                                                                                  metric := m.(map[string]interface{})["metric"].(map[string]interface{})
                                                                                  retMap = append(retMap, metric)
                                                                          }
                                                                  
                                                                          return &retMap, nil
                                                                  

                                                                  It works, it’s all stdlib, but cludge-y sounds right.

                                                                  1. 3

                                                                    Yeah, i tried implementing it using the struct pattern(?) and am not sure if it looks any better

                                                                    https://play.golang.org/p/hQFozwUjn7V

                                                                    1. 3

                                                                      You can remove the json:"..." annotations when fields are named the same (capital leter at front is matched when parsing), and in this case also inline more structs, and then you get: https://play.golang.org/p/9xWMnrjc9Hw. The structs is how it’s generally intended to be used. Anyway, static typing requires the types to be written at some point, so there’s no avoiding this, if you want to keep the advantage of a typed language. You can look at the types list as a “schema” for the JSON. In the end, I don’t really understand what’s “not looking any better” here.

                                                                      1. 1

                                                                        I found this helpful for quickly generating golang structs from example json: https://mholt.github.io/json-to-go/

                                                                  2. 2

                                                                    Go has standard library support for JSON, so I’m not sure how it’s lacking. Dealing with optional keys or variable structures is a bit cludge-y, but that’s a problem in most typed languages.

                                                                    1. 3

                                                                      I found Go’s JSON support to be great but potentially confusing for beginners due to Go’s weird mix of high and low level abstractions.

                                                                      It’s not as simple as, say for example, Python’s JSON support where you load the file and it spits back a Python Dict you can use.

                                                                      1. 2

                                                                        To be honest I was kind of hoping it would be more python-like, but it is what it is. I want to give go a try at least and the use case I’m having in mind seemed perfect for it. Unfortunately it will require json that’s highly dynamic so I’m not sure how to tackle this but I’ll give it a a try.

                                                                        1. 2

                                                                          Yeah it’s absolutely NOT python-like, and its adherents see this as very much a feature, not a bug.

                                                                          Not every programming language is for everyone, and it’s not exactly clear that Go is for me, at least for a lot of the work I do most of the time.

                                                                      2. 1

                                                                        I’m not sure how it’s lacking

                                                                        exactly.

                                                                        I generally use points for optional fields which are nil & use json.RawMessage for data that is structured like a tagged union.

                                                                        1. 2

                                                                          Have you tried implementing json.Unmarshaler for the tagged union fields? I’d expect it’s one of the use cases where it should be useful?

                                                                          1. 1

                                                                            I use this pattern generally.

                                                                            I haven’t used Unmarshaler before but if I understand correctly, it would be helpful when there is only one ‘output’ struct.

                                                                            1. 2

                                                                              My idea, applied to your example, would be something more or less like this: https://play.golang.org/p/MKCosTwXa6N. Depending on how you’d want the data structures to look in the end, there’s some wiggle room for tweaking this/reframing somewhat differently.

                                                                              1. 1

                                                                                ah, thanks!

                                                                                this would have been perfect if we had sum types. type Error = NotFound | Denied

                                                                    2. 1

                                                                      You might enjoy this post: http://eagain.net/articles/go-dynamic-json/

                                                                    3. 2

                                                                      I don’t understand the bit about Ansible playbooks - what does it mean you’re not going to maintain them yourself? then who’s gonna do it for you?

                                                                      1. 3

                                                                        Ansible Galaxy is basically a place where you can publish roles and other people can download them. There are a lot more talented people maintaining playbooks and it always costs me time when a major new version comes out. After talking to some people at the event I just figured I’d at least try using one or 2 roles to see where I got, and I ended up migrating 70% of everything in an hour or 2. The geerlingguy’s roles are what I’m using.

                                                                      2. 2

                                                                        Regarding parsing JSON with Go, I agree that it can be difficult, but you can make your life much easier by using the GoJSON tool. It automatically generates struct definitions from the JSON that you provide for it. Hope you find this useful!

                                                                      1. 9

                                                                        One question that the author didn’t answer is ‘Why Ada’? There are so many languages that would have prevented this bug, why should the authors use Ada specifically.

                                                                        • C++’s destructors would have removed the need for calling *Free completely
                                                                        • Go’s defer would have made sure that *Free functions were called
                                                                        • Java’s try-finally or try-with-resources would have eliminated the case as well
                                                                        1. 6

                                                                          You’re sort of taking his point backwards…it’s not “which languages would prevent this particular bug” but “look at the techniques Ada uses to make it hard to create bugs”. This is just example #1.

                                                                          1. 4

                                                                            They did: it was systematically designed to eliminate as much error as possible followed by easier maintenance. If you want details, this free book gives them chapter by chapter. The ToC alone gives a good idea of what areas they considered and tried to make safe.

                                                                            For more safety, Praxis did SPARK. For parallel stuff, Tucker Taft followed up with ParaSail.

                                                                          1. 8

                                                                            Morning all!

                                                                            I’m keeping busy, it seems.

                                                                            I’ve got more changes in progress for the Z3 theorem prover to clean up some more platform support issues. I’m also working on expanding my Rust bindings as well.

                                                                            In Zircon / Fuchsia land, I got a lot of my backlog of changes cleared out and then went and submitted a bunch of new changes. One day, Zircon will be the OS kernel with the best spelling.

                                                                            My client work is progressing. The devil is in the details and I’m trying to get everything nailed down in the next day or two.

                                                                            I’m still reading up and learning about things going on in the materials world with cellulose and lignin. This led me to the interesting world of using chitin from shrimp and crab shells, producing chitosan, and then using that to make biodegradable plastics. So fascinating! A lot of this seems like it needs further work to bring it into affordable production processes though. I’m trying to find some local chemical or materials engineers to meet up with and learn more about this.

                                                                            I’m also reading about some ideas from the 1990s on what might be better than a REPL. Also pretty fascinating.

                                                                            And this coming weekend, we undergo 30 or so hours of door to door travel to head to the US for a couple of weeks.

                                                                            1. 2

                                                                              I’m also reading about some ideas from the 1990s on what might be better than a REPL. Also pretty fascinating.

                                                                              Sounds very interesting, can you share some links and/or thoughts?

                                                                              1. 3

                                                                                Right now, I’m looking at the thesis of Wolfgang Weck: ftp://ftp.inf.ethz.ch/pub/publications/dissertations/th11817.abstract

                                                                                This is rooted in the Oberon world. This was also similar to how MPW worked way-back-when.

                                                                                @nickpsecurity also posted a link to a paper from the Oberon world on ActiveText recently. That’s related to this as well.

                                                                                1. 1

                                                                                  Thanks for credit. That’s this paper for folks wondering. Honestly, I haven’t read it yet due to lack of time/energy: it just looked really good as I skimmed it seeing ideas I’ve seen in other good work. I guess I should bump it up on my backlog since you’re recommending it. Might do Weck’s at same time since you say they’re related.

                                                                                  Note: Weck’s stuff is paywalled but I found a page with links to dissertations that was broken. I’ll email admin in case any of those links were free PDF’s and they fix it.

                                                                                  1. 2

                                                                                    I’ve had the Active Text paper around for a while myself … but you re-brought it to the front of my mind as I was looking into similar things again. :)

                                                                                    As for Weck’s thesis: ftp://ftp.inf.ethz.ch/pub/publications/dissertations/th11817.ps.gz

                                                                              2. 1

                                                                                I’m also reading about some ideas from the 1990s on what might be better than a REPL. Also pretty fascinating.

                                                                                I love this stuff! It’s really interesting to see the things that were tried, and that…well, not that failed, but that didn’t become popular. I think by the 1990s we were pretty doubled-down on the edit-compile-debug cycle, and sufficiently burned by CASE tools to be sceptical of anything more complex than a text editor with a “build” button.

                                                                                Some stuff never left academia, some didn’t get traction, and some was genuinely not a good idea :). Trying to work out which is which is fascinating.

                                                                              1. 3

                                                                                Just downloaded and installed this in a VM on MacOS after seeing this post. Basically ubuntu with an actually pretty nice UI toolkit effort and all the ubuntu repos. No doubt some other differences under the hood too. Default browser seems reasonably slick, and firefox runs smoothly. Interestingly as soon as it booted up I got a warning from Oversight on MacOS that the microphone was in use. Which seemed a bit odd for an OS touted for privacy; maybe just a VM thing. Anyway, seems like a pretty viable option for bringing older machines back to life. Thanks for posting, I never remember to check for updates on these sorts of projects and at this point Elementary seems pretty solid, from the (elementary!) check-out/test I did.

                                                                                1. 3

                                                                                  VM doesn’t really do it justice, I would recommend that you at least try it using a live USB.

                                                                                  The microphone thing is weird, do you remember any more details? when did it happen during the boot process?

                                                                                  1. 3

                                                                                    Hiya, was just going to update this thread that I did try it in a live USB this morning, on a non-retina Macbook Air 13” and a retina 15” MBP. Looks great and works really well, especially on the higher res. Pretty impressed really - it seems really viable as a day-to-day OS, the UI toolkit and a lot of the OS-level touches are great, especially for a Mac user. Great work!

                                                                                    Tried the VM again just now to check the microphone alert, it happens right before the desktop picture displays for the first time.

                                                                                    1. 1

                                                                                      Awesome!

                                                                                      Interesting, I’ll experiment to check if that was due to the kernel/underlying system checking USB/devices. Which virtulization software did you use on the mac?

                                                                                      1. 2

                                                                                        Cool - Virtualbox, latest version installed via brew on a new High Sierra install at the weekend.

                                                                                        1. 1

                                                                                          Circling back on this - just noticed the same audio warning during the boot process when running another VM. So that seems like it’s nothing to do with Elementary :-)

                                                                                  2. 2

                                                                                    Thanks for mentioning Oversight, I was just looking for something like this.

                                                                                  1. 6

                                                                                    I think it is great that they are trying to polish the Linux desktop and bring in donations for Linux developers. However, I am ambivalent about how they do it. They have their own GNOME 3 fork (Pantheon), their own human interface guidelines, their own app store, etc. Further splintering may give some local optima, but I don’t think it is useful to the Linux desktop in general.

                                                                                    1. 4
                                                                                      • Pantheon is not a fork, it uses libmutter which is also used by gnome-shell.
                                                                                      • The app store is open source, any distro can use it

                                                                                      Further splintering may give some local optima, but I don’t think it is useful to the Linux desktop in general.

                                                                                      That’s the beauty of Linux and open source software in general, if something doesn’t fit an individual or groups needs, they are free to modify it.

                                                                                      1. 5

                                                                                        Personally, I think one of the contributing factors to Linux’s failure to capture the desktop is fragmentation. That said, I’m looking forward to playing with Juno.

                                                                                    1. 3

                                                                                      I, like many fellow engineers, wrote my own called muda. Why “Muda”? Because productivity is waste. It’s web-based and completely written in C++. Unfortunately, it doesn’t compile with the latest version of Wt

                                                                                      1. 2

                                                                                        a screenshot in the readme would be helpful.

                                                                                        1. 2

                                                                                          Thanks, good idea. Will do that when i get it runnig with the new version of Wt.

                                                                                      1. 6

                                                                                        “promotion decisions come from small committees of upper-level software engineers and managers who have never heard of you until the day they decide on your promotion”

                                                                                        While that has been true until now, it just changed, at least for Sr. Software Engineer and below.

                                                                                        1. 1

                                                                                          Whats the new method?

                                                                                          1. 2

                                                                                            Now it’s a set of sr. engineers who work in the same product area and will know what every candidate worked on.

                                                                                            1. 1

                                                                                              Both the procedures are eerily similar to my current company. I guess people take cultures with them to their new workplaces.

                                                                                        1. 3

                                                                                          Yes, my work enables me to achieve my non-work life goals (or that’s what I tell myself when doing boring tasks). I work at one of the humongous tech companies sometime the work is interesting and sometimes it frustrating to deal with the politics but this is my first full time job.

                                                                                          I used to be a very regular contributor to OSS and my day-job isn’t nowhere close to that rewarding.

                                                                                          1. 4

                                                                                            Really want this to happen, i used to write and maintain lots of apps for elementary OS and all are written in Vala. Most new contributors were turned off due to so few resources available.

                                                                                            Do reach out to @elementary on twitter, they would be more than happy to help/support the effort.

                                                                                            1. 2

                                                                                              I was at Poor till a couple of week ago and started getting burnt out so i am trying to progress to Average.

                                                                                              1. 2

                                                                                                Pony is a pretty interesting language, i really enjoyed reading the paper. Definitely on the “to learn next” list.

                                                                                                1. 1

                                                                                                  If you run into trouble, you can ping us on IRC, mailing list or twitter. I think you’ll find it a very welcoming community.

                                                                                                  1. 1

                                                                                                    Thanks!

                                                                                                    I have been bugging you on irc for a couple of weeks now :)

                                                                                                    1. 1

                                                                                                      I’m good with faces. Not so good with nicks and names.