1. 14

    “Congressman, I don’t have all the answers to your very technical questions…”

    That’s not something you hear everyday. Who is this Riggleman guy?

    1. 7
      1. 2

        It’s interesting because he sounds decently familiar with GitHub. I wonder how many Congresspersons have GitHub accounts, if any?

        1. 5

          Perhaps your expectations of congressman is so low that the ability and initiative to use a website to do research is the more surprising part, because it doesn’t take a lot of familiarity with Github to perform a search. He did sound familiar with programming on more than a surface level, however.

          1. 7

            He was able to talk confidently about nightly toolchain builds though, which takes a fair amount of technical understanding.

            1. 12

              His mention of DoD practice leads me to think he picked this up as an intelligence officer. You don’t have to be an experienced developer to recognize high-level risks. Extrapolating from a single point of experience working for a former I.O. for several years, they have a keen skill for picking through details.

              1. 1

                He was also an NSA contractor.

                1. 1

                  I think he did indeed mention he had a background in intelligence.

              2. 4

                What jgb said. He talked like a programmer or project manager, not someone vaguely familiar with it.

                1. -5

                  It’s not so much low expectations it’s just the average age of a congressperson is 57, so it’s kind of new to see folks who would be familiar with something like Git.

                  1. 29

                    About half my computer science lecturers at university were older than that, and they were all familiar with git. My dad’s about that age, and he’s familiar with git.

                    57 isn’t actually particularly old. Many of the pioneers of computer science have died of old age at this point. We’re well past the point where programming or computer science is a ‘young man’s game’ in any reasonable sense.

                    1. 5

                      The number of programmers doubled roughly every 5 years for a long period of time. Possibly from the beginning up until recently. This suggests that there are 64 times more 25 years old programmers than there are 55 years old programmers. Yes, all the pioneers are now old. But they were exactly that: few pioneers.

                      Programming has never been a young man’s game, but this exponential growth skews the numbers like crazy, and make it appear like a young man’s game. After all, if the only thing you know about someone is their age, the older they are, the less likely they are to have learned programming.

                      1. 2

                        there was definitely a dip in the rate of CS enrollment after the dotcom bust in 2000, but then numbers of both major and nonmajor CS exposure has seen a massive surge since 2005

                        1. 1

                          Very well explained, thank you!

                        2. 8

                          Linus Torvalds himself turns 50 this year.

                          1. 4

                            57 and working in computer science is different from the average 57 year old who may not have an in-depth exposure to computer science.

                            1. 20

                              I wouldn’t expect that the average 57 year old has a better or worse idea of git than the average 21 year old. People often claim that young people are better with technology. In my experience, they tend to not be at all.

                              1. 4

                                In my experience, they tend to not be at all.

                                Young people work for cheap and are more easily taken advantage of.

                                Why do you think so much of advertising is aimed at people in their twenties? Some disposable income and not as much life experience.

                                1. 3

                                  Yeah, the average 21 year old also has no exposure to computer science either. I agree it’s a pointless comparison.

                              2. 2

                                Good point! My bias is showing (growing up where I did, the only people I knew who knew about computers were my age). This makes me hopeful that I can still be programming well into retirement age :)

                        3. -1

                          Yuck

                          1. 1

                            I agree that his tie isn’t the most flattering, but I wouldn’t necessarily say “Yuck”.

                            Care to elaborate?

                            1. 1

                              Lol I didn’t notice the tie. Purely a political yuck. He’s proud of bombing Afghanistan, pro-trump tax cuts, pro-deregulation, and anti-gun control. ¯_(ツ)_/¯ to whether his staffer gave him talking points on rust and javascript.

                      1. 2

                        I think it’s odd to list “interviewer time” as an issue with the current system and then offload a day of work onto the interviewee as if the current process isn’t expensive enough from that angle.

                        1. 7

                          TLDR: Author used several bad IDEs, which crashed to the point of rebooting so that restarting after a reboot alsotook a long while.

                          Well, now I really want to know on what kind of potato the author was running which IDEs. JetBrains IDEA is not lightweight but I’d used it for 4 years on an x230 (ok, i7 with 16GB and SSD) without any problems. Multiple projects, multiple languages, multiple VMs running at the same time. Now I use QtCreator and it’s a joy.

                          Not using IDEs is fine, but the concept of an IDE is absolutely not the problem here.

                          1. 1

                            Intellij crashes on me at times. Are you sure you haven’t had any problems?

                            Edit: Don’t take my question as an endorsement of this article, which it is not. 🙂

                            1. 1

                              You never have not any problems ;) But I’ve definitely had less problems than when using non-IDEs. (Sure it crashed once in a while or was stuck at “indexing” - but it’s given me less problems than, say, my browser, IRC client, mail client or anything else. Maybe I was just lucky :P) But just opening many files and switching between them multiple times per minute, resplitting panes, etc. It’s doable in vim/tmux/etcc (for me) but there’s no “intuitive flow” and forget about plain editors.

                              1. 0

                                wink wrote:

                                … ;) …

                            2. 1

                              JetBrains has some quality IDE’s. For me, PhpStorm has features that I haven’t found in other IDE’s let alone text editors. I’m guessing this is similar to other languages too. For example IDE’s that support and extend hot swapping for Java.

                            1. 12

                              Typescript has become my favourite language for side projects and I’ve even snuck it into the Day Job. The dynamism of JS with a fairly rich type system at “compile” time is a fantastic combination.

                              I suspect that part of what’s great is that the type system has been built to be expressive enough to capture real JS usage and APIs. Instead of being a static type system imposed on a dynamic languages it’s a type system suited to the language and its users.

                              1. 1

                                Every static type system is a type system imposed on a dynamic language. Are you meaning to compare to flow here?

                                1. 7

                                  Au contraire! You have it backwards. Dynamic languages do have static types – just, not very expressive ones.

                                  https://existentialtype.wordpress.com/2011/03/19/dynamic-languages-are-static-languages/

                                  1. 3

                                    Au contraire your au contraire! Static languages have dynamic types, but they’re so weak you need to run a SECOND program just to make sure you don’t accidentally use them!

                                  2. 3

                                    Not so, some languages are built from the ground up with static types. There’s no way to implement Haskell (typeclasses) or Scala (implicits) without implementing a de facto static type system.

                                    1. 1

                                      Haskell is built from the ground up with types, sure. In a sense though it is still a series of extensions to the untyped LC. Type classes are type level computation and therefore a part of the type system so their absence doesn’t make a great counter example.

                                      Granted this is all a lot more hair splitting than my original question.

                                      1. 1

                                        I think the major difference is that some languages expose untyped constructs to language users, while in other cases untyped constructs are just hidden artifacts of a compiler implementation that are invisible to users.

                                        1. 0

                                          the issue is these terms are vague with conflicting alternative definitions. None of this is relevant to clarifying the second paragraph I was asking about.

                                        2. 1

                                          Haskell is built from the ground up with types, sure. In a sense though it is still a series of extensions to the untyped LC. Type classes are type level computation and therefore a part of the type system so their absence doesn’t make a great counter example.

                                          What do you mean? There’s no sense in which a Haskell expression like (decode x) - can be understood from an untyped perspective. Both its semantics and its behaviour are fundamentally entangled with what type the expression has.

                                          Granted this is all a lot more hair splitting than my original question.

                                          It’s not “hair splitting”, your original claim is false and misleading.

                                        3. 1

                                          Further at runtime the type information about a generic parameter is almost totally lost, you need to have an instance to base type information off of. There are real weaknesses with bolting strong typing onto dynamically typed runtimes.

                                          1. 1

                                            Generics should be erased at runtime, having them there only makes it easier to violate parametricity.

                                            1. 1

                                              From the perspective of someone who’s written multiple ORMs and other serialization frameworks … this is objectively wrong. You need to know what fields are on an object, and be able to call into generic functions with strongly typed parameters to make sure things like interfaces are still satisfied.

                                              Typescript is a step forward for javascript devs but it is still very, very lacking compared to something like golang even.

                                              1. 1

                                                Take a look at how ORMs and serialization frameworks are implemented in Scala or Haskell sometime. Implementing those things requires ad-hoc polymorphism, but that can be done at compile time rather than at runtime, via typeclasses or similar mechanisms. This is better for maintainability and understandability of code than doing runtime reflection on reified generics, because it makes the distinction between parametric and ad-hoc polymorphism visible to the programmer - one can immediately see which functions will always follow the same code path at runtime, and which maybehave differently for different types.

                                                1. 1

                                                  You get compile-time guarantees with reified generics too; and they end up being safer and more expressive (and faster in a lot of cases). I’m not sure what you’re arguing for other than less expressive systems are easier to understand.

                                                  1. 1

                                                    A lot of guarantees the reader would expect from a parametric function can be violated if that function uses runtime type information. https://failex.blogspot.co.uk/2013/06/fake-theorems-for-free.html gives a few simple examples - const3 is only possible to implement because the types are present at runtime. The only thing that reified generics give you compared to erased generics is the ability to implement functions that use the mechanism that const3 uses, and such functions are a bad idea.

                                                    (There are problems that you might assume could only be solved by writing functions like const3 - you mentioned ORMs and serialization - but actually it’s perfectly possible to solve those problems without reified generics)

                                                    1. 1

                                                      You’re mixing paradigms here.

                                                      I’m an ORM. I see a type. I need to create a binder at runtime to take a database row result and map it to the fields on that type. I can either have the user create mapping functions to do this manually, or I can examine the type, dynamically emit that mapping function for them (in .net you can do this with IL/Lamda.Compile()), saving the developer a lot of steps per type.

                                                      One runtime approach creates a lot of manual work for the developer. One does not. The second order affects that reification creates for functional programming (specifically the corner cases you outlined) do not outweigh the other benefits of having full type information at runtime. Especially in a runtime that can dynamically emit and load types.

                                                      1. 1

                                                        I’m an ORM. I see a type. I need to create a binder at runtime to take a database row result and map it to the fields on that type. I can either have the user create mapping functions to do this manually, or I can examine the type, dynamically emit that mapping function for them (in .net you can do this with IL/Lamda.Compile()), saving the developer a lot of steps per type.

                                                        Again, look at how this is done in Haskell or Scala. You put a typeclass constraint on your loader function, and the language uses typeclass derivation to generate the mapping codepath at compile time. You get the safety of compile-time type checking, but the developer doesn’t have to do any extra steps (depending on the language they might have to add a marker like deriving (DatabaseMappable), but they never have to manually implement the mapping functions).

                                    1. 1
                                      1. 24

                                        I agree. A huge donate bar seems very out of place for a site previously so focused on being able to apply filters and focus on content.

                                        And I really don’t care about adopting… an emoji…

                                        1. 4

                                          What changed in my reasoning?

                                          First of all, I’m working on other problems. Whereas I used to do a lot of work that was very easy to map to numpy operations (which are fast as they use compiled code), now I write a lot of code which is not straight numerics. And, then, if I have to write it in standard Python, it is slow as molasses. I don’t mean slower in the sense of “wait a couple of seconds”, I mean “wait several hours instead of 2 minutes.”

                                          So, basically, the author is solving problems Python isn’t good at. So, great - use another tool, Haskell or whatever. I do not see how this says anything useful or interesting about the language itself other than “Python is not optimized for solving numerical problems not addressed with numpy”

                                          1. 2

                                            Is Haskell well-optimized for numerical problems?

                                            1. 8

                                              It’s OK. The mainline compiler doesn’t have vectorization by default yet. See https://ghc.haskell.org/trac/ghc/wiki/SIMD/Implementation/Status . For some classes of numerical algorithms, you can expect performance on par with (unvectorized) C. For algorithms that are inherently mutation heavy, I generally find that making Haskell exactly as efficient as C removes many of the benefits of using Haskell in the first place. That’s fine for library writers but not great for end users.

                                              Haskell’s main strength wrt speed is that you can compose high-level things and the abstraction overhead will be unreasonably small. If you’re churning through gigabytes of data per second, you can write Haskell that’s almost as fast as really well optimized C for a small fraction of the effort. However, I wouldn’t really describe the problems this works well on as “numerical”. When I think of “numerical” I usually thing of lots of mutations on big matrices, for which I would rather use Numpy or something. Haskell’s good for many of the things numpy isn’t.

                                              1. 2

                                                I may be wrong but my understanding was that haskell does have library support for generalized stream fusion which gets very good performance without having to write particularly clever code.

                                                https://www.microsoft.com/en-us/research/wp-content/uploads/2016/07/haskell-beats-C.pdf?from=http%3A%2F%2Fresearch.microsoft.com%2Fen-us%2Fum%2Fpeople%2Fsimonpj%2Fpapers%2Fndp%2Fhaskell-beats-c.pdf

                                                1. 1

                                                  That’s exactly what I meant by

                                                  you can compose high-level things and the abstraction overhead will be unreasonably small

                                              2. 1

                                                Excellent question - I have zero idea. It’s compiled, right? So I’d think there’s more room for optimization there, but I dunno.

                                            1. 2

                                              “Type theory is a theory of computation that classifies programs according to their behavior, rather than their structure. Types are themselves programs whose values stand for specifications of program equivalence.”

                                              I had to stop right there. Most of us in imperative languages using types use them or structure. Especially in terms of structs or objects. This says types have nothing to do with structure. Makes me wonder if that’s inaccurate or type theory doesn’t cover what imperative/OOP programmers normally call types. Or do they have another definition of structure outside the mainstream definition. I have a feeling a certain amount of confusion that happens in type theory discussions might have started right there.

                                              Regarding the RedPRL prover, one person on it is the person who wrote Practical Foundations for Programming Languages. People might find those interesting by themselves.

                                              1. 8

                                                An example of something that structural interpretations of types have trouble with is equality of functions. Many programming languages have a very limited or outright broken notion of function equality, but it’s important if you want to prove a program conforms to a specification. It’s also important to have a language for what function equality means. Are a quicksort and a merge sort equal functions?

                                                Bob Harper is both the author of this blog post and PFPL.

                                                1. 3

                                                  Type theory is a theory of computation that classifies programs according to their behavior, rather than their structure. Types are themselves programs whose values stand for specifications of program equivalence.

                                                  I took “behaviour” to mean the ‘externally visible’ aspects of a value/program. For example, that something with function type Foo -> Bar can be called with a Foo value to produce a Bar value; that something with product type Foo * Bar can be projected to give both a Foo value and a Bar value; that something with sum type Foo + Bar can be projected to give either a Foo value or a Bar value but not both; etc.

                                                  I took “structure” to mean the ‘internal’ aspects of a value/program. For example, the different parts it may be made out of, any functions/computations that it uses (delayed or already completed), the syntax it was written as, etc.

                                                  In this sense:

                                                  • We can make these “behaviours” as complex and precise as we like, by making the types more complex and precise. For example, with dependent pairs and functions we can encode arbitrarily complicated mathematical relationships between values, inputs/outputs, etc.

                                                  • We can’t use types to classify the “structure” of a value/program.

                                                  As a provocative example, we can think about a value of product type Foo * Bar. We might think that the type tells us some ‘structural’ properties about the value, like “it contains a Foo” and “it contains a Bar”, but that’s not quite right. All we know is the “behaviour”, that we can project the value to get a Foo and a Bar, but we don’t know what will happen during that process. For all we know, the value might be an integer plumbed into an ‘unpairing’ function, like with Cantor pairing or Goedel numbering. Should we say that such a value “contains” a Foo and a Bar? What if that same integer is also used elsewhere to generate a boolean, a list of bitmaps, etc.? We’d at least have to weaken what we think of as “containing” or “structure”.

                                                  One example which I’ve heard discussed about type theory as opposed to set theory, is that in set theory we can (and very often do) ask whether a value is contained in a set, e.g. foo ∈ {foo, bar} and foo ∈ {high, low} are propositions which may be true or false. In type theory we can’t ask whether a value has a particular type, e.g. foo : (Foo * Bar) and foo : (High * Low) aren’t true/false propositions; they’re logical statements, which may be well-typed (valid) or ill-typed (invalid).

                                                  This is important for the “behaviour” vs “structure” distinction, since in set theory we can distinguish between isomorphic sets, e.g. {foo, bar} and {high, low} are isomorphic (they “behave the same”), but the foo ∈ x predicate is true for one and false for the other (they’re structured differently). Since type theory doesn’t let us do this, isomorphic types are indistinguishable (within the theory), so we can only reason about “behaviour”. This has connotations for modularity, reusability, optimisations, etc.

                                                  1. 3

                                                    You’re right that the types discussed in here are not being used in the same way that types in many c likes primarily use them. The goal is essentially different in scope. C types mostly capture the size of memory required for allocation of something. Types in the type theory sense can capture this idea, but can also contain much richer and complicated concepts in the types themselves.

                                                    also aside from PFPL Bob Harper is known for his work on SML and LF

                                                    1. 2

                                                      Yeah I don’t think you can do type theoretic proofs in say C# without a lot of work with interfaces and tuples. After all you don’t even have “Product and Sum types”. Heck it’s even hard right now in F# due to the fact that you have to explicitly name everything.

                                                      So for example say you have a function which takes a tuple of an int and (bool or string) and returns either a tuple of an int and a bool or and int an a string. int * (bool | string) -> (int * bool) | (int * string) //this would be the function signature. More amusingly

                                                      Old * (dumb | fat) -> (Old * dumb) | (Old | fat) // if I’m old and (dumb or fat) this implies I’m either old and dumb or old and fat

                                                      This is equivalent to A ^ (B v C) = (A ^ B) v (A ^ C). in logical propositions.

                                                      we can the write a function which takes an int and either a bool or a string, and return an int and bool, or an int and string and we know we have covered all possible return combinations.

                                                      In this way the function signature, the “Type” represents the lemma and then function itself exists as proof.

                                                      This as I understand it is merely the beginning of the whole thing. There’s a good computerphile video on the subject.

                                                    1. 1

                                                      re: always be considerate (ABC): while providing a language that does not enforce static types may have been “considerate” for user adoption, it has left us with a world where a frightening portion of major fiscal and scientific operations are carried out in a tool where writing correct software requires a lot of skill.

                                                      Maybe it’s considerate and expedient, but is it right?

                                                      1. 3
                                                        import java.util.stream.*;
                                                        
                                                        public class Triangle {
                                                            public static String triangle(int rows) {
                                                                return IntStream
                                                                        .rangeClosed(1, rows)
                                                                        .boxed()
                                                                        .map((row) -> Stream.iterate(row % 2, (n) -> n == 0 ? 1 : 0)
                                                                                            .map(Object::toString)
                                                                                            .limit(row)
                                                                                            .collect(Collectors.joining(" ")))
                                                                        .collect(Collectors.joining("\n"));
                                                            }
                                                        
                                                            public static void main(String[] args) {
                                                                System.out.println(triangle(4));
                                                            }
                                                        }
                                                        

                                                        Yes, it looks much uglier than Haskell version, but constructs are almost the same.

                                                        (I’m not arguing that you can avoid imperativeness in Java, you almost can’t, and even Streams are imperative but somewhat composable)

                                                        1. 5

                                                          to be fair, java 8 (and streams) had only been out in the wild for 5 months when this was written.

                                                          1. 3

                                                            But are those features of Java actually taught at university? Because they sure don’t spend time on them where I’m at.

                                                            1. 2

                                                              I haven’t run across it, though I could imagine some contexts where they might be. I might even consider doing it in the future, given the right circumstances. But I think they’re not that likely circumstances. Usually university courses are trying to teach at least two things with a programming language (or language construct): the language itself, and some broader principle, which students will hopefully retain long-term and be able to apply even when languages inevitably change over. So typically Java has been used either as “generic intro-level language” or “OO language”, which Java 8+ streams don’t fit that well into.

                                                              In universities where Java’s used as the standard intro-level language, there’s some advantage to continuing to scaffold atop it for further things, because you can assume everyone already knows the basics. But it’s falling out of favor for intro-level classes in favor of Python. So I think you will either see people introducing this “streams” style of programming in Python if the circumstances fit, or else they’ll stick with a more traditional introduction to sequence filtering/mapping/etc. in the context of an introducion to functional programming, in Haskell or ML or maybe some Lisp dialect.

                                                              1. 1

                                                                So I think you will either see people introducing this “streams” style of programming in Python if the circumstances fit, or else they’ll stick with a more traditional introduction to sequence filtering/mapping/etc. in the context of an introducion to functional programming, in Haskell or ML or maybe some Lisp dialect.

                                                                I’m aware of some libraries that provide special syntax for that in Python, but I don’t think anything other than list comprehensions (and maybe higher-order functions) for this kind of stuff is considered “Pythonic”.

                                                          2. 3

                                                            I did much the same but tried to introduce names in the same places as in the original; as relatively idiomatic Java that’s:

                                                            public class Triangles {
                                                                public static void main( String[] args ) {
                                                                    System.out.println( triangle( 4 ) );
                                                                }
                                                            
                                                                public static String triangle( int n ) {
                                                                    return IntStream.rangeClosed( 1, n ).mapToObj( Triangles::line ).collect( Collectors.joining( "\n" ) );
                                                                }
                                                            
                                                                public static String line( int n ) {
                                                                    return alternating( n ).limit( n ).mapToObj( Integer::toString ).collect( Collectors.joining( " " ) );
                                                                }
                                                            
                                                                public static IntStream alternating( int start ) {
                                                                    return IntStream.iterate( start, i -> i + 1 ).map( i -> i % 2 );
                                                                }
                                                            }
                                                            

                                                            You can also go totally crazy, but I wouldn’t recommend it:

                                                            public class Triangles {
                                                                public static void main( String[] args ) {
                                                                    IntFunction<IntStream> alternating = i -> IntStream.iterate( i, n -> n + 1 ).map( n -> n % 2 );
                                                                    IntFunction<String> lines = l -> alternating.apply( l ).limit( l ).mapToObj( Integer::toString ).collect( Collectors.joining( " " ) );
                                                                    IntFunction<String> triangle = n -> IntStream.rangeClosed( 1, n ).mapToObj( Triangles::line ).collect( Collectors.joining( "\n" ) );
                                                            
                                                                    System.out.println( triangle.apply( 4 ) );
                                                                }
                                                            }
                                                            
                                                            1. 2

                                                              Great, now I want to my own version but I have to work…

                                                              1. 5

                                                                I wrote mine too! ;)

                                                                Funny how similar Rust and Haskell are in those small examples.

                                                            1. 3

                                                              This was referenced in the post but if you’re looking for a packaged up implementation that does take advantage of some type family level stuff see Richard Eisenberg’s units library

                                                              1. 17

                                                                I don’t really agree with this, in basically any meaningful way, mostly because the writer has their head up their ass.

                                                                Expectations for what a web site should be able to do have evolved enormously. […list of bullshit follows…]

                                                                And they want a pony and a snow cone and anything else devs are stupid enough to claim they support. And frankly, I’d argue that devs are projecting on users quite a bit: devs want to build fast apps with instant loading service workers and spiffy SPA stuff and all the rest, not users.

                                                                You know how I know this? Go look at “boring” but huge-traffic sites. Go look at 4chan, at Reddit, at Stack Overflow (notice that the tabs load a new page, every time), at Craigslist. And then come back and tell me that somehow users are clamoring for anything more complicated.

                                                                The functional and popular web only needs basic things.

                                                                The web as a platform, as ever, lags behind its developers. They want ES6 syntax, they want modular JavaScript, modular CSS and modular HTML. Browsers provide none of these things, so they are hacked together in frameworks.

                                                                The browsers provide none of those things because they aren’t necessary–no more required than say stabby lambdas in ES6. Hell, if you want “modular” things, consider just using different script tags and IIFE. We had those for ages and they worked fine.

                                                                Devs aren’t adopting all this new tech just because it’s new and fun (though it’s a bad idea to dismiss fun as a valuable quality in a development tool). They are doing it because they have to in order to survive.

                                                                Bullshit. Most new tech comes out because of one or more of:

                                                                • Learning how to use existing tech/APIs is hard.
                                                                • Making your own new APIs is fun work that isn’t as boring as delivering customer value. (see also yakshaving)
                                                                • It’s harder to sell product than it is to sell consulting–and you get street cred for being the dev who made X/Y/Z (the new hotness)
                                                                • It’s harder to build a reputation for building solid applications than to give conference talks.

                                                                Are there some people using a huge pile of JavaScript and a monstrous build chain to throw together a single-pager web site with one box that collects an email address? For sure. And that’s silly and unnecessary. But so what? The misuse of technology does not invalidate it.

                                                                How many billions (BILLIONS!) have been wasted by companies trying to have mudball jQuery applications cleaned up? How many man-centuries have been wasted waiting for an over-built “web app” to load to display a static document? How many gigawatts (and fuel and so on) are wasted on processors crunching spurious bullshit JS that never needed to be there?

                                                                This is a fucking plague. This is ludicrous spendthrift garbage. This culture of ignored externalities is killing us, folks.

                                                                Over the next 5 years I expect there will be a lot of consolidation in technologies and in tools.

                                                                No, because web assembly is going to let every chucklefuck use their pet language and framework(s). It’s going to be the goddamn tower of babel. Things are going to get so much worse.

                                                                jQuery was a performance problem at scale, and sometimes over- or mis-applied, or used superfluously by newbies who didn’t know there was a simpler way. Big deal.

                                                                Again, author clearly has no empathy for the poor schmucks who have had to actually deal with solving the messes left by other developers who shared the author’s philosophy–or the people signing their paychecks.

                                                                Nobody but nobody loves the web more than I do. It’s my baby. And like a child, it’s frustrating to watch it struggle and make mistakes. But it’s amazing to watch it grow up.

                                                                The author’s child is the little shit that runs around and sets fire to squirrels and breaks things and the author is a shitty parent for celebrating that behavior and telling other parents to let their kids do the same.

                                                                ~

                                                                And then I saw that the author is an exec at npm, and it all makes sense.

                                                                Of course the author shills for the “evolving” web, because their business is predicated on that growing cancer and shitty development. Of course they’re going to insist “This is fine, this is the way things’re supposed to be”–their livelihood depends on it!

                                                                Author: You write shitty software. Your company writes shitty software. Your views on engineering are a net negative on the web. You are a bad person and you should feel bad.

                                                                1. 5

                                                                  Personal attacks are not acceptable here.

                                                                  1. 12

                                                                    Was I attacking another user of this site? No.

                                                                    Was I pointing out that the author knowingly supports bad software that directly impacts in a negative way thousands of developers? Yes.

                                                                    Look, saying that “@gambogi you’re a goddamned carebear and your face is ugly and you stink” is a personal attack. Pointing out that somebody online in a position of power is making the world a worse place by their actions is not.

                                                                    Now, perhaps “you are a bad person” should be person-first language “you are a person with bad thoughts and actions”–mea culpa.

                                                                    EDIT:

                                                                    Let me make vent a little more on this point.

                                                                    A few years ago I had to deal with the stupidity of npm. I had to deal with npm’s decision to just use nested dependencies, with their derpy version management (shrinkwrap having been eventually introduced). Others had to deal with the entire left-pad debacle, but I personally along with my team wasted man-days on this.

                                                                    That was time I didn’t get to spend with my family. That was time I didn’t get to spend exercising. That was time I didn’t get to spend posting online. That was time I didn’t get to spend eating, fucking, singing, playing, cycling, dancing, or anything else that makes me a human being.

                                                                    That is time I’m never getting back.

                                                                    And this bozo? This is the person responsible for the engineering that caused those problems.

                                                                    We have to hold engineers accountable for their actions.

                                                                    1. 0

                                                                      THE PACKAGE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS “AS IS’ AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES.

                                                                      1. 1

                                                                        That doesn’t make it morally correct, especially when the package is being shoved down people’s throats with VC marketing money.

                                                                    2. 4

                                                                      If people can’t interpret text at all, they shouldn’t be online.

                                                                      Nothing is as frustrating to read as apologetic “I’m sure you are a nice person with your family, and even Hitler painted roses, but when it comes to your position in the public eye and the way you exert power, I find your actions disagreaable to say the least, and if political correctness had not won, I’d call them outright evil!”

                                                                      It’s ok to say someone’s bad every once in a while and let the reader figure it out.

                                                                    3. 2

                                                                      I agree with you. I just want to point out that mobile reddit is complete and utter JS-laden abomination. They probably know how bad it is, because they heavily advertise their mobile application. I even think it is intentionally bad, to push the app down their users throats.

                                                                      1. 2

                                                                        It used to be so simple too…

                                                                        1. 2

                                                                          I’m a fan of their .compact view: https://www.reddit.com/.compact

                                                                    1. 6

                                                                      When I saw this I thought I had accidentally submitted a partial draft with the exact same title

                                                                      1. 1

                                                                        I thought about making something like facebook before facebook existed.

                                                                        1. 3

                                                                          Instead, you posted about it on Lobste.rs, and in an alternate timeline, The Zuck just stole it, ran all the way to a time masheen, and now look where we’re at.

                                                                      1. 15

                                                                        What’s described isn’t a company, it’s a software project.

                                                                        1. 3

                                                                          Multiple projects with the same rules == company, isn’t it?

                                                                          1. 4

                                                                            Nope. I’m part of consulting company, so the “rules” in our project widely diverge, as we often support external projects.

                                                                            1. 3

                                                                              From what I know about Thoughtworks, they meet a lot of these requirements, and also are a mainly consulting-based company. Sure it’s a lot of work to ensure you can enforce your requirements when working with clients, but it probably pays off in the long run.

                                                                              1. 1

                                                                                Thoughtworks is often “we do the whole project from you”-consulting, because that sounds nicer then “team-selling”. We consult for specific technologies and are just 10 people, spread over 5 projects, most of the time.

                                                                                Sure, it makes sense, and they can do that, but I enjoy solving hard database problems where people have direct issues, I’m not gonna enter their building and start by introducing new development methodologies first. (unless they may be a source of the problem)

                                                                              2. 2

                                                                                Everything I wrote was about internal software projects, so I scaled this to the company. Maybe I’m wrong with these assumptions.

                                                                            2. 1

                                                                              This. I’m slowly thinking about career direction and while technicalities are interesting, the foremost thing is the business model and people - is it something I’m morally okay with? Do the people have a DNA where I feel like “the worst drummer in the band” (I.e. a feeling that I’m learning)? Will the work be spread such that I’m not just assigned things nobody else wants to do?

                                                                            1. 28

                                                                              I’m not sure why this is share-worthy. What is the content here that people are upvoting? Not trying to be snarky - genuinely interested if there was something I missed.

                                                                              1. 20

                                                                                I’m not sure why this is share-worthy.

                                                                                Not sure why it isn’t. It’s an interview about a [good] dev and an open-source maintainer, and the post fits perfectly under the person tag :)

                                                                                1. 17

                                                                                  The title needs to be fixed to be more useful (is the link her personal site, a biography, some post about her?).

                                                                                  1. 9

                                                                                    She has been one of the more consistently public, helpful, and relatable faces of Docker for years. Good presentations and demos.

                                                                                    1. 23

                                                                                      It’s not really that much about her, though, unfortunately.

                                                                                      It reads like “docker kubermetes docker, a couple observations about open source, generic advice, plug for help for docker or kubermetes”. She seems like a perfectly nice person, but she doesn’t seem that much more noteworthy than any of a thousand other open-source developers paid to work on infrastructure projects. The interview doesn’t really cover anything personal about her, it doesn’t have her saying anything we haven’t heard a thousand times before or at least going in-depth on a story to explain her advice. The systemd->butts transform was amusing, to be sure, but otherwise why?

                                                                                      I hate to be this, well, mean, but shouldn’t we be using the person tag for people of, well, note?

                                                                                      ~

                                                                                      And yes, this is kind of a core problem with the person tag. This person isn’t that interesting–given the information in the submission–to me, for example, but I could probably pick some alternate submissions that might be equally uninteresting (a person I know who is a greybeard at GOOG and has some cool projects.

                                                                                      But where to draw the line without being petty? What makes articles under people good articles (instead of PR puff pieces)? Therein lies the rub.

                                                                                      1. 10

                                                                                        I get that anger is in your username and stuff but if you describe your own post as mean it’s probably not constructive.

                                                                                        1. 5

                                                                                          She is without question “of note” in the open source community. Especially in the infrastructure / “devops” space.

                                                                                          If you don’t know her, maybe that’s not your thing?

                                                                                          1. 9

                                                                                            I think the problem here is that the interview doesn’t really say enough to convince someone that she’s worth interviewing. If you know her, you get it. If you don’t, then… we’ll, this isn’t helping, unfortunately.

                                                                                            1. 3

                                                                                              You’re right. Unfortunately, I don’t know that anyone who’s already “soaking in it” will take the time to write the “Hey, all you folks not in Devops, this is why Jesse is awesome!”.

                                                                                              Maybe a little bit of open mindedness on people’s parts would help?

                                                                                              1. 2

                                                                                                Maybe a little bit of open mindedness on people’s parts would help?

                                                                                                Yes! This is the key. We should probably trust our community a bit more than suggest an post with a decent number of points is irrelevant.

                                                                                            2. 2

                                                                                              Clearly not “without question”, right? Perhaps in the Docker/Kubermetes realm, but the article itself really doesn’t give much information about her, why she’s a big deal, or what she’s done. And that sucks, because people here are pointing out waaaay more interesting accomplishments she’s had.

                                                                                              But again, the problem with the person tag is that you and I can both draft up a list of at least a half-dozen devs that are “of note” and yet the other one of us will go “huh?”. And in a few decades time, probably none of the people on those lists will be remembered.

                                                                                              1. 2

                                                                                                IMO it comes down to what people want this community to be about.

                                                                                                I can totally see the angle where “person” violates the spirit of the place - what makes Lobsters great is all hardcore tech - all the time.

                                                                                                I can also see the idea that showcasing awesome community contributors could be a good thing.

                                                                                          2. 5

                                                                                            The person tag is for stories about people, not profiles. A link to one of her talks, an in-depth or technical interview, or any one of a number of her blog posts would not have been flagged as off-topic.

                                                                                            edit: I’ll also point out that in general the person tag is used alongside another tag. Cases of “person” alone are generally of some historical significance, an interview, or a death announcement; all of which are more substantive and/or better discussion topics than a simple profile.

                                                                                          3. 5

                                                                                            I’m with you. The title alone means nothing to me. I thought it was going to be some sort of memorial when I first saw it. But there isn’t really much of any content there. There’s nothing technical in it. I don’t understand what we’re meant to get from it.

                                                                                            It fits HN more because that site is full of fluff like this, but I wouldn’t expect it here.

                                                                                            1. 14

                                                                                              I completely agree, this is not the kind of content I want to see here.

                                                                                              1. 2

                                                                                                FWIW this was only posted in here because it’s in the front page of HN. @av consistently posts whatever is popular there here (most of the time it makes sense, though).

                                                                                                1. 4

                                                                                                  I like this content, but I don’t think that something reaching the front page of HN is a good litmus test for if it should be cross-posted here

                                                                                              2. 4

                                                                                                Lots of people don’t know where to start, and stories like this can be helpful. Lobste.rs has previously made similar pages for some of our users.

                                                                                                1. 1

                                                                                                  Well, the community has voted for it so I guess you’ll just have to avoid clicking the link and move on then.

                                                                                                  1. 3

                                                                                                    By the same argument tabloids are the best because there’s lots of demand for them!

                                                                                                1. 37

                                                                                                  So it starts off saying “not meant to be insulting to anyone or anything” and then, a bit below, they decide to take “designed for stupid people” as an actual reason of why Go is not good? I can’t say I’m impressed.

                                                                                                  1. 21

                                                                                                    To be fair, the author is just listing what other people have said about go and their major points. The author themselves did not say that Go is “designed for stupid people”, they included someone who did say it.

                                                                                                    1. 20

                                                                                                      I refuse to accept that as valid; quoting someone is an action too. Author could have decided to leave that out, because let’s face it, it brings nothing to the table. Both of the articles cited for that point have a lot of other stuff that they are cited for, as well. To be fair, I’m probably nitpicking, but it still irritates the hell out of me when people pull together a list of reasonable concerns, and then plop in a “you’re stupid” trump card. I’ve worked with the “you’re stupid” trump card for a year and a half, now. I really dislike it. A lot.

                                                                                                      [Edit: when I say “work with”, I mean “had a coworker who kept a trump card unreasonable argument nearby at all times”]

                                                                                                      1. 3

                                                                                                        Personally, I would feel i’d either have to leave the article out entirely (which may have been what I did) or include the “point” in the list. It would have felt incomplete/wrong to me otherwise.

                                                                                                        1. 1

                                                                                                          i got voted down as a troll for saying this in another subthread, but direct, deadpan quoting of someone who says something over-the-top is a definite form of humour. “psuedointellectual arrogance of Rob Pike and everything he stands for” was a big tell, but the overall “tone” of the page is subtly (and i’d bet intentionally) funny, regardless of whether it serves a useful purpose or not.

                                                                                                      2. 5

                                                                                                        I doubt they’re falling Go users stupid; it’s probably a reference to Rob Pike’s (one of Go’s creators) comment “They’re not capable of understanding a brilliant language but we want to use them to build good software. So, the language that we give them has to be easy for them to understand and easy to adopt.”

                                                                                                        1. 4

                                                                                                          It was definitely a poorly expressed point by Rob Pike but making a language easy to use is absolutely the whole point of language design. And really, Go is very easy to learn and provides a very low barrier to getting real work done. So that’s a great thing.

                                                                                                          1. 4

                                                                                                            making a language easy to use is absolutely the whole point of language design

                                                                                                            That is really not the case. “Ease of use” is only one dimension of a language, and one that’s commonly overoptimized for to the detriment of other properties like correctness, efficiency, readability, maintainability…

                                                                                                            Google “rich hickey simple made easy”

                                                                                                          2. 1

                                                                                                            Okay, so a hit on pride, but how is that a shortcoming of the language? If it’s a driving point of design decisions, it would result in the language being weak-sauce, but in and of itself, it’s not a weakness of the language.

                                                                                                            1. 2

                                                                                                              Personally I’ve never understood the comment as developer mistakes seem like the greatest motivator for strong type systems and uh, not including null.

                                                                                                          3. 1

                                                                                                            “I’m sorry if you feel offended”.

                                                                                                          1. 2

                                                                                                            Am a bit underwhelmed by this article, as a long time Python programmer I’ve been eyeing Haskell for years but never invested the time to try for real. I would love to see an article from someone who made the jump, like Brian O'Sullivan.

                                                                                                              1. 2

                                                                                                                Stephen Diehl has a pretty comprehensive list of useful things to know: http://dev.stephendiehl.com/hask/

                                                                                                                1. 2

                                                                                                                  not haskell, but you should enjoy the posts about 0install’s migration from python to ocaml

                                                                                                                1. 7

                                                                                                                  Stage 4: Composability is destroyed at program boundaries, therefore extend these boundaries outward, until all the computational resources of civilization are joined in a single planetary-scale computer… this is the idea of Unison and unison.cloud.

                                                                                                                  I feel like a couple reasoning steps were skipped between the assertion and the conclusion on this stage.

                                                                                                                  1. 4

                                                                                                                    That’s because this could be construed as clever marketing/advertising. :)

                                                                                                                  1. 3

                                                                                                                    I’m not a rust person, figured I’d give it a try.

                                                                                                                    Can’t get the hello-world example to build because cargo can’t fetch the crates index because of some git issue talking to https://github.com/...

                                                                                                                    Every time I try projects like this, and the tooling is wonky, it makes me appreciate golang that much more.

                                                                                                                    Fascinating that someone voted this down as (incorrect). I can show you my terminal if you want, this did actually happen, and is actually a defect.

                                                                                                                    1. 5

                                                                                                                      Too bad this happened. Given the limited info you gave it could be different things: 1. a transient error connecting to github 2. a proxy in use that somehow breaks the connection 3. using a broken version of cargo (yes, we had that recently…)

                                                                                                                      From my own experience I find the Rust tooling far more reliable than what Go offers.

                                                                                                                      1. 2

                                                                                                                        Do you think that’s because golang has concretely better tooling in some way or because you’ve grow accustomed to its quirks? I’ve experienced the promising new library without a working example a lot, regardless of language. I’d be curious to hear what approach go takes that can address it.

                                                                                                                        1. 5

                                                                                                                          Quirks that hang up new golang devs:
                                                                                                                          * $GOPATH
                                                                                                                          * the import system
                                                                                                                          * (new) vendoring

                                                                                                                          Things that golang gets right:
                                                                                                                          * When things fail, they fail in very transparent ways. An example would be, if I had the above issue, I would 100% be able to reproduce it if I tried a git clone myself, vs. rust where it’s not shelling out and it’s some other configuration or library issue.
                                                                                                                          * golang has no configuration files, everything you need can be inferred by what’s on disk.

                                                                                                                          Basically it comes down to, an initial hurdle of slight magic with golang, and then extreme transparency and logic with everything after that initial acclimation period.

                                                                                                                        2. 2

                                                                                                                          On other end of spectrum, I had to try to code something in a hurry on a new computer without knowing tooling or programming due to memory loss. FreeBASIC did a simple install, I/O worked as in tutorials, typed stuff into text editor, and ran compiler with terminal command.

                                                                                                                          Effortless just like QBasic I started with ages ago. Another good one from my early time was LISP box or something like that. Integrated everything from editor to compiler in one executable. Stuff like this is how I judge how easy tooling is to install and get running with.

                                                                                                                        1. 1

                                                                                                                          I like type safety but this seems restrictive. If I had, for instance, gotten an array of numbers from an external library I would need to turn it into a RandomSample just to compute inferential statistics on it. If I already knew it was, then at that point I would coerce or call a constructor before I used the library; but since I’m still the one making that decision, it is the same as if I had just abandoned specific statistical types entirely.

                                                                                                                          1. 8

                                                                                                                            Not quite. For whoever comes along after you the explicit typing of the entire computation would at a minimum enhance the readability of what has been done. Having some record of the assumptions made in an analysis would actually be pretty fantastic and make reading statistical code less of a nightmare.