I think it is really important that it is as easy as possible for some kid to just figure out they want to make a web app, and have something on the screen really fast. These are some of my notes from seeing all kinds of people learn how to code in a professional enviornment for the first time.

• Anything that requires you to do many steps to get something on the screen can be really discouraging. Any framework like .NET Core, Rails or Django is like this, for good reasons, but this makes it harder to get started.
• React and JavaScript is something experienced developers struggle more with, than new ones. Because they’re probably not that used to much else.
• Anything where you can start simple figure out one thing and then introduce another and repeat seems to work well.
• Stuff like React and Express have worked out well, because you add a line of code and seconds later you see it on the screen. And you can keep it all in one file.
• Make sure the tooling works as much out of the box as possible. The easier this is the faster the’ll learn

I think the most important thing if you try to make things easier for beginners (and not what some old dude think is difficult and therfore it must be harder for beginners) is to listen to some beginners.

There are some problems with JavaScript. For example how broken math is or how much it pretends to be a C# or Java like OOP language.

But JavaScript is in general great. We get a new version of the language every year, that solves real problems. And there are new tools and libraries showing up each month (sometimes each week) that try to solve a problems a lot of people have. The great thing about this is that what is a real pain point in 2018 is very different from 2019.

This isn’t all without issues however. The negative side to thing becoming a little bit better more or less all the time is that you as a developer will have to spend more time keeping up to date than you would in a slower moving community.

But I’m in general mostly happy with where JavaScript and Node have been moving.

• Michael Tsai - Blog - Why Generics in Go?
• 404 Found
• List comprehensions across languages
• JavaScript to Know for React
• defmacro - The Nature of Lisp
• AdoptOpenJDK
• Apple Card Account Information Is Only Accessible Via iOS Wallet App
• Announcing notqmail
• In Search of a Stack That Monitors the Quality and Complexity of CSS | CSS-Tricks
• 5 Interesting Uses of JavaScript Destructuring
• Inferno
• carson-katri/reddit-swiftui
• json.pizza
• .NET Memory Management posters – TooSlowException
• Logic-less JSX | Jonathan Verrecchia
• nurpax - Dirty tricks 6502 programmers use
• What is the difference between parallelism and concurrency? - LispCast
• Tumblr
• YAML: probably not so great after all
• ebooks-could-be-real-books
• More thoughts about ebooks and real books
• I Failed at Using Elfeed as My RSS Reader
• cljs-http
• Nvidia CEO says Google is the company’s only customer building its own silicon at scale
• pokemonsay
• React Hooks: everything you need to know! 🚀
• My Workflow with Org-Agenda
• Vim Within Emacs: An Anecdotal Guide
• Literate Programming with Org-mode
• The Differing Perspectives on CSS-in-JS | CSS-Tricks
• Tom Bihn’s New Synik 22 and 30 – The Brooks Review
• SOLID Design: The Single Responsibility Principle (SRP) - NDepend
• Try out Nullable Reference Types | .NET Blog
• Shallow Testing Hooks with Enzyme
• Comparing Postgres JSONB with NoSQL | The Couchbase Blog
• Doom Emacs tweaks: Org Journal and Super Agenda · but she’s a girl…
• ‘Studies in Power’: An Interview with Robert Caro
• Library patterns: Why frameworks are evil
• SOLID in Test Automation #2: Liskov Substitution Principle
• The React Hooks Guide - Tutorials and Examples | KendoReact
• A Future Without Webpack
• React v16.9.0 and the Roadmap Update – React Blog
• Advanced Test-Driven Development In C# - CodeProject
• Use React.memo() wisely
• A Complete Guide to Email in Emacs using Mu and Mu4e

I started to write all my custom command line tools in Node a while back. It was less than a year ago, but more than six months ago. The reason is simple, if I can put them up on NPM I can run them everywhere using npx without having to think about installing or keeping stuff up to date.

A lot of people have problems with JavaScript and Node for various reasons. Some because it change a lot(I think it is great because then things get better a lot faster) others don’t like that it is async (it is only a issue until you get used to it, and stuff like async and Promises have made it a lot easier).

What I enjoy a lot about this strategy is that the tools are solid, and that I can use third party libraries to solve a lot of stuff.

I do not regret moving all of my python, perl and shell script stuff over to node, it has made everything a lot easier to manage.

The big thing going on in React this year is to move away from class based components to pure functional ones that use Hooks where it is possible. And if you are doing React development I recommend that you start doing this as soon as possible. You should at least get used to hooks.

I like hooks a lot better than I have ever liked class based components, and they are a lot easier to make re-usable. But they can be a little bit confusing in the beginning. Especially if you have not started using them yet.

My bet is that the React team will add hooks that solve the remaining things only class based components can do in the next couple of releases. What usually happens when something change to something new in React you usually get a couple of years before you start seeing warnings and then another year before it is gone. And it is a lot easier to deal with this kind of change if you start doing it early.

• Dapper In .NET Core - Part 4 - Dapper Contrib - .NET Core Tutorials
• Dapper In .NET Core - Part 3 - Updates/Inserts/Deletes - .NET Core Tutorials
• Dapper In .NET Core - Part 2 - Dapper Query Basics - .NET Core Tutorials
• Introducing the New React DevTools – React Blog
• Michael Tsai - Blog - Keyboard Maestro 9
• Don’t Let Your Hobbies Die
• Twitter
• David’s Log
• plumatic/dommy
• Tumblr – AVC
• Michael Gandolfini Opens Up About the Difficult Decision to Step Into His Father’s Role of Tony Soprano
• Tumblr the Day After
• The Differing Perspectives on CSS-in-JS | CSS-Tricks
• Think Twice Before Returning null
• Dapper In .NET Core - Part 1 - The What/Why/Who - .NET Core Tutorials
• Update on .NET Standard adoption | .NET Blog
• These Legit-Looking iPhone Lightning Cables Will Hijack Your Computer
• NetNewsWire 5.0
• What’s the big deal with IAsyncEnumerable in .NET Core 3.0?
• JavaScript: What’s new in ES2019 - Tilde Loop Blog

Most emacs power users would probably agree with the statement from the Emacs Manual about Emacs being more of a computing platform than just a text editor.

If you know a Emacs power users you have probably noticed how we sometimes try to move stuff to emacs that seems a little bit weird to do in a text editor. Like reading email or rss feeds. Those are two of the things I recently have moved back into emacs.

When something works in emacs I really love doing it there, because I prefer having as much as possible in there because it makes my workflows and setup a lot easier. But if it doesn’t work that well there I just get rid of it. One example of something I want to do in emacs that doesn’t work at all is browsing. And one thing I don’t do a lot in emacs is shell stuff, because I haven’t really found a good enough way to do it.

When you build a product outside of a MVP mindset you define what you’re trying to make. And then you make a list of features that makes sense based on that. But also based on what people expect to have there. Back in the day we all always expected to be able to import and export data in all online services.

But when you are doing things like an MVP and follow incremental improvement, instead you try to find what are the minimum we can make that are useful to our users and that give them enough value to continue using it. And then you start adding features based on feedback and where you see pain points.

This means that a lot of “obvious” features will probably never make it, because they are nice to have, but neither you see the pain points or the users ask for them enough.

I’m of the mindset that some features should be there, not because you need them or because people want them, but rather because it is the right thing to do.

It is interesting to look at the effects different ways of working can have on your product.

As always, the most important thing is do build stuff in a way that makes sense to you. If something would annoy you if it wasn’t there, add it.

• React v16.9.0 and the Roadmap Update – React Blog
• How Redux Connect compares to the new Redux Hooks.
• Build your own unbeatable Tic Tac Toe with React Hooks and Styled Components | Oleksandr Khomenko
• 22 Miraculous Tools for React Developers in 2019
• 5 Tips to Help You Avoid React Hooks Pitfalls
• Lesser known npm CLI commands
• How to create and run cron jobs in Node
• Async Generator Functions in JavaScript
• Your August nvUltra update
• Focussing on the Wrong Things When Starting a Blog
• A Framework for Moderation
• Leica M4 is out of storage
• JavaScript: What’s new in ES2019 - Tilde Loop Blog
• ASP.NET Core 3.0 Exception Handling - Simple Talk
• 5 Programming Languages That Are Probably Doomed
• .NET Framework to .NET Core to Docker
• Being basic as a virtue
• Sweet.js - Hygienic Macros for JavaScript
• Review: Tom Bihn Synik
• The Surprising Benefits of Automation - LispCast
• Community Tools and Templates for Clojure CLI Tools
• Buttsss
• Switching from Common Lisp to Julia
• Michael Fürstenberg
• Why Emacs
• jonase/eastwood: Clojure lint tool
• Terminating Service for 8Chan
• Why the French love to say no
• Development Workflow With Clojure CLI Tools
• How Does the Development Mode Work?
• Records v2
• Effective mocking
• ASP.NET Blog | HttpRepl: A command-line tool for interacting with RESTful HTTP services
• Advanced Test-Driven Development In C#
• Using Redux with React Hooks - Should You Though?
• A Scheme Syntax-Rules Primer
• The Compositional Nature of Vim - Ismail Badawi
• JavaScript End to End Testing Framework
• Bringing A Healthy Code Review Mindset To Your Team — Smashing Magazine
• Code
• Lefthook: Knock your team’s code back into shape — Martian Chronicles
• Postgres tips for the average and power user
• Code
• Deconstructing the Monolith: Designing Software that Maximizes Developer Productivity
• Code
• Top 25 Javascript Plugins for Webstorm & IntelliJ
• esprint - a fast eslint runner
• Understanding RxJS Observables and why you need them - LogRocket Blog
• My VS Code setup - Making the most out of VS Code
• First-Class Functions in JavaScript
• ES proposal: optional chaining
• Learn Gatsby for building blazingly fast apps and websites in React course by Jason Lengstorf
• http://wiki.c2.com/?WhatIsNull
• Here’s why Nintendo Switch consoles keep frying
• The perfect language (and why Go still isn’t it)
• Gerbil Scheme
• The Birth of the Semicolon
• The Web We Want
• Inside Ethel Kennedy’s cruel neglect of her troubled kids
• Why React Hooks?
• Dependency injection in Node.js
• Caporal
• Cypress.io: the Selenium killer - LogRocket Blog
• The Day After | Andy Ihnatko’s Celestial Waste of Bandwidth
• Programming Algorithms: A Crash Course in Lisp
• Parallelism in PostgreSQL
• Combined indexes vs. separate indexes in PostgreSQL - Cybertec
• Andy Jones
• Labcodes - Decoupling logic from react components
• Writing your own React custom hooks | Timothy Vernon
• Auto Refreshing Cache in .NET · _hao
• Managing a Secure JSON Web Token Implementation
• Why Generics? - The Go Blog
• Fujinon XF 16-80mm f/4 R OIS WR first look preview
• Don’t ask if a monorepo is good for you – ask if you’re good enough for a monorepo
• Where is Windmill on the iPhone?
• notqmail/notqmail
• Loper OS » Why Hypercard Had to Die
• SOLID design: The Liskov Substitution Principle (LSP) - NDepend
• Chuck Klosterman Likes Writers Who Aren’t Self-Absorbed Sociopaths
• Why You Only Need to Test with 5 Users
• Bezos: A CEO Who Can Write
• Contracts — Draft Design
• Mindfulness is loaded with (troubling) metaphysical assumptions – Sahanika Ratnayake | Aeon Essays
• Personal growth for broke people - Annie Mueller
• Introduction - Mithril.js
• Cross-origin resource sharing - Wikipedia
• The Complete Introduction to React
• Cutting Edge - ASP.NET Core gRPC Services

Powershell is something I have to deal with at work, because we’re on windows, and all our internal tooling is written for it. Not a huge fan of it, but it is what it is.

I think it is a great interface to write scripts and automate stuff. But I do not enjoy using it as a shell.