Eric Elliott

Not much said on the category of bugs caught by Typescript. That would have been an interesting discussion. I dip between javascript and typescript and hesitate recommending it for large scale project for a large team as much as I would like to, coming from a background of typed languages on the backend. There appears to be a need for experienced senior typescripters on the team to prevent falling into certain traps and onboarding [1]. I do wonder though how he saw typing as over-engineering. It may cause intertia which he hints at in the next sentence but over-engineering is a bit uncharitable. [1] https://medium.com/javascript-scene/the-typescript-tax-132ff4cb175b

In contrast, https://www.simplethread.com/cant-replace-redux-with-hooks/ https://daveceddia.com/context-api-vs-redux/ https://medium.com/javascript-scene/do-react-hooks-replace-redux-210ba… TL;DR Context can replace some but not all of Redux. Redux can figure out which components to rerender based on what's being computed. Context doesn't, so it's basically the same as refreshing your entire component tree every time something changes. You could build it yourself, but at that point, you're just reinventing Redux. I also like the Redux Toolkit (https://redux-toolkit.js.org/) which is an opinionated way to write Redux that cuts down the boilerplate a lot. createSlice is easily one of the best features, you can encapsulate Redux logic for each different type of content, like authentication, users, posts, etc.

Eric Elliot does a great analysis on this: https://medium.com/javascript-scene/the-typescript-tax-132ff4cb175b

If you're referring to ["The TypeScript Tax"](https://medium.com/javascript-scene/the-typescript-tax-132ff4cb175b), Eric never said it was useless. "Many developers love using it, and there are many aspects of the TypeScript developer experience I genuinely love." There's a whole section called "What I Love About TypeScript" and he even uses it in some of his open-source projects. What he actually says is that there is a cost to using TypeScript (an obvious fact). And most JavaScript developers use [object concatenation](https://medium.com/javascript-scene/the-hidden-treasures-of-object-com… all the time, especially with Redux. He's right - every JavaScript developer should know what it is and how to use it, even if they don't recognize it by the word "concatenation".

As someone that would be new to his code base, I neither find that confusing nor am I mislead by it. Here's a blog post I'm becoming more and more persuaded by as time goes on: https://medium.com/javascript-scene/nested-ternaries-are-great-361bddd…

This article captures a few good reasons as to why composition is much preferred over inheritance: https://medium.com/javascript-scene/a-simple-challenge-to-classical-in…

I agree with the GP about Discover Weekly; it works great for me but I'm guessing maybe that's because I have a lot of saved playlists I've accreted over the years. I disagree about the native app, though. PWDs are where it's at now. Native apps are doomed.* I didn't even download it on my new MBP, it was slow and buggy. The web version is good enough for me, combined with web-scrobbler for Chrome so I can still scrobble to Last.fm. [*] https://medium.com/javascript-scene/native-apps-are-doomed-ac397148a2c…

"Who doesn’t like explicit inheritance, like in Java language, instead of writing magic code for prototypal inheritance?" There's nothing magical about prototypal inheritance code, and I'd suggest the class keyword is more magical since it's "primarily syntactical sugar over JavaScript's existing prototype-based inheritance" [1]. Furthermore, encouraging classical inheritance constructs without mentioning the classic pitfalls is somewhat harmful [2]. [1] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Clas… [2] https://medium.com/javascript-scene/javascript-factory-functions-vs-co…

It's possible to write javascript without `this`, a style preferred e.g. by Douglas Crockford, explained in the video below. https://www.youtube.com/watch?v=PSGEjv3Tqo0 I've also started to write my code mostly without `this`, `class` or `new`, not looking back. Another related, highly recommend reading: https://medium.com/javascript-scene/the-two-pillars-of-javascript-ee6f…

I like Eric's writing style. He made a post before that offered a little more perspective on tech hiring: https://medium.com/javascript-scene/the-recruiter-plague-how-recruiter… What I particularly liked about this article is that he made it obvious that instead of recruiters, "tech agents" are really the best way to get hired at great companies. It's analogous to music industry's managers who arrange a gig and the band just have to the venue and play great music.

Classical inheritance sucks. https://medium.com/javascript-scene/the-two-pillars-of-javascript-ee6f…

I used to use Karma / Mocha... Now I advocate that people use Tape. There's a great article [0] about tape, which I'd suggest giving a read! If you want to run your tests on all the browsers, you can use zuul [1], which is also dead simple to use! [0] https://medium.com/javascript-scene/why-i-use-tape-instead-of-mocha-so… [1] https://github.com/defunctzombie/zuul

ADTs are only concerned with the "shape" of the data and what interactions you can have. It is related to classical OOP in the sense that the "interactions" you can have are equivalent to the message passing from the original conception of OOP[1]. The distinction is similar to database design in SQL: the Schema is how the data is laid out and what the relationship between tables is (ADTs) while the queries is the operations performed on them (traits). On the other hand, in OOP there's a higher reliance on encapsulation, making behavior an integral part of what the class is and using inheritance for expansion. When all you have is ADTs, you _can't_ have inheritance, so you end up using composition (which is generally considered better design) and you are more likely to rely on the creation of "new-type" container types for everything. You think of them as a way to describe what the data is, not how you interact with it. Apologies if this is a bit hand-wavy, I'll try to write a more thoughtful answer at a later time. [1]: https://medium.com/javascript-scene/the-forgotten-history-of-oop-88d71…

> I don't buy these hypotheticals and also I don't believe in this kind of anecdotal evidence. The only anecdotal evidence I've linked is Stripe's experience with Sorbet. The paper linked is an actual scientific analysis with great study design. I couldn't find the Airbnb slides or talk but an engineer involved claims the study was carefully designed[1]. > When you look at reports of bug density across large samples of projects, it's clear that TypeScript does not solve any problems. See https://medium.com/javascript-scene/the-shocking-secret-abou... Go read the "study" referenced in that article. It's just blog post with a terrible methodology. It's basically (number of issues with bug label) / (lines of code) The author doesn't even normalize for LOC (larger codebases tend to have more bugs) or take into account project complexity. [1]: https://twitter.com/swyx/status/1094857103863209985 EDIT: add disclaimer about airbnb talk

As others have said, key at this point is going to be to prioritize in relation to business needs. As hard as that all will be, the process will only get more difficult the longer you wait. I'd also suggest one thing you prioritize personally for yourself whatever happens is eight hours of sleep every night. :-) As other have also said, you're also going to have to tailor the way you present the message about the facts (i.e. the "alarm") to your current organization's culture and your specific situation in it. You'll need to keep in mind your own talents/resources and current limitations in developing a message or plan (see also "Dunning–Kruger effect" for risks on that). Talents/resources and limitations include your own ability to present a message and what help you can rely on from the rest of the organization to develop a message and present it based on what your coworkers, manager, and management chain value. If you eventually want to reflect on the larger issues that may have gotten you to this unfortunate situation and what your company can do better in the mid-term and long-term, here is a reading list I put together that includes multiple books on software engineering management as well as broader surrounding issues -- including a great book by Matthew Walker on the importance of adequate good sleep for everyone in an organization: https://github.com/pdfernhout/High-Performance-Organizations-Reading-L… One item from there: "Why Deadlines Need to Drop Dead" by…

> However, it is not a matter of opinion whether software safety (and therefore availability) benefits from checks performed before run-time. The article I linked to (it's still there for me?[1]) linked to another article[2] which in turn mentioned a paper[3], which conclusion is: > The data indicates functional languages are better than procedural languages; > it suggests that strong typing is better than weak typing; that static typing > is better than dynamic; and that managed memory usage is better than > unmanaged. [...] > On the other hand, even large datasets become small and insufficient when they > are sliced and diced many ways simultaneously, [...] Hence, we are unable to > quantify the specific effects of language type on usage. So I still think there's no way to tell, for example, if a statically typed imperative language with manual memory management is better than a dynamically typed functional language with a GC. I think it's a case of "all else being equal" in the context where "all else" varies drastically. The argument is not about if static typing improves safety (because many things do) but instead by how much and if that increase in safety is worth the drawbacks it comes with... Which again is subjective and situation-dependent. In other words, even if we agree that static typing has a positive effect on some metric (like number of bugs) it's not going to move the discussion forward. > Conversely, it is not a matter of…

I recognize that we can have different goals, and you may value flexibility over safety. However, it is not a matter of opinion whether software safety (and therefor availability) benefits from checks performed before run-time. Conversely, it is not a matter of opinion that dynamic languages allow patterns that static typing does not (eg. duck typing[sic]). These are objective arguments we can discuss, and weigh against each other. There are even studies that we can throw in here. >> Nowadays I see no notable arguments for dynamically typed programming languages. >A quick Google brought up an article from Dec 2016: https://medium.com/javascript-scene/you-might-not-need-types... I glanced over it the other day and wasn't very interested. I wanted to give it a more thorough look before I replied to you, but it seems it got pulled. looks meaningfully >What about Elixir and Clojure? I see your Erlang dialect Elixir with Elm (arguably a dialect of ML). The Lisp Clojure is itself a bit older dialect of Lisp, so maybe Scala for that? I think Lisp and Erlang are mostly about the paradigm and concepts, not about being dynamic, what do you say? Talking about the JVM, I'll raise you a Kotlin. Also noteworthy is that Groovy got static type checking with v2. As for the CLR, I must say I don't know that much have changed since F# (a dialect of ML). Basically, you've had a nice pair of cards, but they make your hand. What I'm trying to reiterate is that there seems to be a definite…

TL;DR: If you share the sentiment of the parent commentator you may find this wall of text interesting. You might be interested in Alan Kay's "Doing with Images Makes Symbols Pt 1", https://archive.org/details/AlanKeyD1987 (46:29). This video features excerpts from Ivan Sutherland's Sketchpad demo (https://www.youtube.com/watch?v=USyoT_Ha_bA, 10:34; https://www.youtube.com/watch?v=6orsmFndx_o, 19:19) and Douglas Englebart's seminal demonstration (https://archive.org/details/XD300-23_68HighlightsAResearchCntAugHumanI… 34:45). I recommend watching all the videos in full to get a proper sense of context (Alan Kay's excerpts from Douglas's demonstration particularly don't include the bits that explain how the workstation's camera system works, which is important; also, the right audio channel in the Alan Kay video unfortunately seems to be dead, while the other videos are much better). Highlights from Alan Kay's video include (in hi..low precedence) info about the Sketchpad's CPU, which you might want to listen to twice so you don't mishear (8:58), some really depressing acknowledgements (from Alan Kay himself) that Sketchpad was a never-reproduced gem even in the 80s (8:33), Ivan's (quoted) remarks on the features of the Sketchpad system (7:58), and acknowledgement about the lack of ease of use of light pens (7:12). I consider the above videos to be my own personal pinnacle, what I look up to when I think about good computer design. Some may find them depressing for…

My favorite thing about react/react native development is the unidirectional flow of data. Specifically I like how it gives you: 1) Deterministic View Renders 2) Deterministic State Reproduction I think the following article gives a good overview of why this is a good idea: https://medium.com/javascript-scene/10-tips-for-better-redux-architect… Quoting from the article: "When your view render is isolated from network I/O and state updates, you can achieve a deterministic view render, meaning: given the same state, the view will always render the same output. It eliminates the possibility of problems such as race conditions from asynchronous stuff randomly wiping out bits of your view, or mutilating bits of your state as your view is in the process of rendering." ComponentKit is another example of a native library inspired by react (also developed by FB): http://componentkit.org/

SeamlessDocs seamlessdocs.com/jobs Soho/Tribeca NYC, NY Positions: Senior Front End Javascript Engineer (React, especially). SeamlessDocs is working to change the way citizens interact with their government. We came out of Code for America, and are supported by the GovTech Fund. We have started with the worst part of government -- forms, and we're making incredible inroads. Government Clerks can upload their PDFs, mark them up, provide signable, public place for citizens to submit building permits, soccer signup forms, or even teacher evaluations. We're still a small team, you would be coming in as a senior front-end engineer to manage and grow the team using the best practices you choose. Qualifications: Read this: https://medium.com/javascript-scene/10-interview-questions-every-javas… If you can answer that, we should talk. [email protected] [email protected] (that's me)

While I think this sheet is a great reference, the level of opinionatedness is a turn off. It strikes me not open to people that might bring a point of view that challenges the author's orthodoxy. Some of the opinions expressed seem to indicate a lack of understanding of successful patterns from outside of the mainstream JS world. I would not use as a filter in hiring. For example, I might agree that composition is better than inheritance if I'd never experienced the joy of algebraic data types. Pattern matching doesn't work out so hot without some concept of "is-a". Languages that support type-classes also tend to avoid the brittle-class problem. I agree that Java style single-inheritance hierarchies are a recipe for disaster, but that's not the only type of class-based inheritance. Scala, for example, has a much better story. While Javascript's prototype system is really powerful, I'm not at all convinced anything more than a small number of library writers should be interacting directly with it. CoffeeScript and ES6 have class stories that are vastly more productive in most cases, in my opinion -- and by the way, are pretty thin layers of prototypes, if someone needs to really hack on that level. In my experience, most people spin monstrosities when they try to hack together their own prototypal logic, when all they is something pretty basic. The author's stamps [1] are very cool. They're more powerful than `class`. But they still expose a level of variation and control…

Related: Nanolang: A tiny experimental language designed to be targeted by coding LLMs https://news.ycombinator.com/item?id=46684958 https://github.com/jordanhubbard/nanolang SudoLang: A Powerful Pseudocode Programming Language for LLMs: https://medium.com/javascript-scene/sudolang-a-powerful-pseudocode-pro… Programming Without People: Designing a Language for LLMs: (ALaS (AI Language Specification)): https://dshills.medium.com/programming-without-people-designing-a-lang… LMQL ("LMQL is a programming language for LLMs."): https://lmql.ai/ Which language is best for AI code generation? The answer might surprise you: https://revelry.co/insights/artificial-intelligence/which-language-is-…

I’m not sure if it went anywhere but I remember there was this attempt at one point called Sudolang: https://medium.com/javascript-scene/sudolang-a-powerful-pseudocode-pro…

The creator of Cuid, Eric Elliot, claims to have run into collisions with UUIDs. I'm extremely skeptical of that claim. It's far more likely that the site he was working on had an implementation issue. Anyway, here's the article where he explains his motivation for Cuid. https://medium.com/javascript-scene/identity-crisis-how-modern-applica…

:) I started with 6800 machine language. Then c, smalltalk, scheme and etc. Rather than spend a lot of time and botch a comparison between classes and factory functions I'll link you to an article. He went further, introducing something he calls stamps, but I found them to be awkward the only time I tried to use them. https://medium.com/javascript-scene/javascript-factory-functions-vs-co…

Frameworks are winner takes it all in nature. I think react is kind of won the market at this point [1]. New frameworks have to wait for a disruption in the model of delivery. React, angular were insight because of SPA. When a new paradigm happens then a new framework will make sense I think. [1] https://medium.com/javascript-scene/top-javascript-frameworks-and-tech…

I've been doing TypeScript for 4+ years and been a web developer for 20+ years. And I experience literally zero benefit from TypeScript. Never has it given me anything useful. To me, it's a massive pain in the ass that slows down myself and my team, even if they think it doesn't. They just don't know JavaScript or have shitty quality of code to begin with. That, and TypeScript generics can get so freaking complex that the code does NOT become simple to read at alllllll. It's a massive waste of time. Also read: https://medium.com/javascript-scene/the-typescript-tax-132ff4cb175b

No. This person seems not understand composition. This pattern can be useful but is poorly employed in this example. If you are interested in good practices please read Eric Elliot's Composing Software https://medium.com/javascript-scene/composing-software-the-book-f31c77…

On one hand you're absolutely correct in that Julia is dispatch-oriented, and doesn't have ton in common with what is commonly considered OOP today. However, as far as I understand it there is also an argument to be made that multiple dispatch is at least as close to Alan Kay’s original intent for OO (e.g. [1]) than is the currently-ubiquitous class-based version of OO that leads to things like `RequestProcessorFactoryFactory` s with `RequestProcessorFactoryFactory.getRequestProcessorFactory(Class)` methods. [1] https://medium.com/javascript-scene/the-forgotten-history-of-oop-88d71…

> OO is about encapsulation and about putting conventionally functions close to the data it operates on. According to Alan Kay, the essential ingredients of OOP are: Message passing, Encapsulation, Dynamic binding. > OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme late-binding of all things. It can be done in Smalltalk and in LISP. There are possibly other systems in which this is possible, but I’m not aware of them. * https://userpage.fu-berlin.de/~ram/pub/pub_jf47ht81Ht/doc_kay_oop_en * https://medium.com/javascript-scene/the-forgotten-history-of-oop-88d71… * https://softwareengineering.stackexchange.com/questions/46592/so-what-… Though it's recognized that Simula invented objects: * https://www.hillelwayne.com/post/alan-kay/