Fannon

Some people claim that unit tests make type systems unnecessary: "types are just simple unit tests written for you, and simple unit tests aren't the important ones". Other people claim that type systems make unit tests unnecessary: "dynamic languages only need unit tests because they don't have type systems." What's going on here? These can't both be right. We'll use this example and a couple others to explore the unknown beliefs that structure our understanding of the world.

I wonder how the new Bluetooth LE Audio with the new LC3 codec would fare in this comparison.

See https://www.bluetooth.com/learn-about-bluetooth/recent-enhan...

There's on thing in the current state of bluetooth audio that actually bugs me: Once you use a microphone, the audio quality significantly degrades from the usually stereo audio quality (which is good enough for me).

I'm curious when we'll see LE Audio in broad adoption and how much of an improvement it will actually be.

Is there a name for this behavior? Sounds like something that is categorized as a cognitive bias?

I'm confident that this does not only apply to programmers :)

But how could "pick the right" people possibly work out for everyone? Maybe some higher paying / more prestigious companies can do that. But that would still leave the other companies with the original problem and not change anything about the industry wide statistics / problem?

However, the author also points out training. So changing the quality of education and the culture around the people can drive this into a better direction.

A quote from the QualityLand 2.0 audiobook by Marc-Uwe Kling:

> The Singularity is always one Kurzweil in the future.

(That is a pun on Kurzweil's name. It consists of two german words that can be roughly translated to "a short amount of time").

Another quote that this may be based on: "The semantic web is the future of the web, and always will be." (Peter Norvig) Source: https://news.ycombinator.com/item?id=8510953

Imho we also tend to underestimate the impact of cognitive biases on our own views and behaviors. We are often largely unaware of this. In this case, I find that Hanlon's razor is to simple with the black and white distinction of incompetence and malice. Biases often fall in neither category.

People who view themself as rational / technical might be even more prone to not realizing how much they are affected by this? If your self-image is that you are very rational person (more rational than others), you might be especially prone to denying and therefore not being aware of biases.

The problem lies in the "should" :) I do agree that the conflation of hours and productivity is a problem here. But it's a very common one and most people don't have the freedom. What I wanted to point out that there is not just one variable in play here. And there are some very practical problems which are not easy to solve. (Try explaining this to your employer and convincing him that this rule would indeed work for every employee he has. There are also jobs where hours and productivity are closer related. There are jobs where hours put in may be the best metric you have to measure output?)

The Dell U3219Q monitor has a (rather rare) feature that gets rid of the need for a KVM switch for me entirely.

It has both an USB-C input and an USB3 upstream that can be combined with either DisplayPort or HDMI. It also has signal auto detection.

When I'm starting up my PC, it will use the USB connection from my PC via USB3 upstream. When I power up my work laptop, it will take USB from its USB-C connection.

That even eliminates the need to push a button to switch. I'm really happy with this setup.

However, people also want to spend more money and have more things / higher standard of living than people had at that time.

I'm curious if you would adjust your own standard of living accordingly, you could finance it with a 15h workweek just fine. But this for sure does not apply to low wage jobs.

While inequality is now clearly on the rise (and it's a big problem), afaik there also have been times in history when it was consistently higher. https://ourworldindata.org/income-inequality seems to have some good charts and context here.

This is something that is really puzzling to me, how such a basic and useful feature can be broken for years. It's annoying me since the release of Windows 8.

Keyboard Launchers like Keypirinha (also used Launchy back in the days) are my current workaround. They can index what the start menu should be indexing and do it right. I also keep my own (synced) folder of shortcuts that I add to the indexing.

Are you aware of tsc options like --watch and --incremental ?

Combined with other live-reloading tools like nodemon or jest --watch you can have almost the same speed of your development-test-run-debug loops as in plain JS. But you do gain an additional instant feedback channel from the compiler.

Pattern matching seems to be a current proposal, also driven by Microsoft: https://github.com/tc39/proposal-pattern-matching

I've had troubles coming to a good software solution or workflow either.

Software wise, I've tryed a few things and settled with MediaWiki and some extensions added. Most notably Semantic MediaWiki (adds structured data storage and querying), Semantic Forms (structured forms) and a Bootstrap based skin. But only the technical setup won't get you far in a wiki, so I've also created a lightweight, flexible "ontology" / structure for knowledge management that was fitting my own needs.

This was not too easy to set up (Finding a structure / ontology / data and query workflow, but also the implementation using the wiki itself), but now I'm quite happy with it as a platform. I really wish there would be a lower barrier to entry for people here. If you're interested, please PM me and I can show you some examples.

As for the workflow of personal knowledge management, I'd be really interested what works for other people as well and I'm still figuring this out.

My current approach is using different phases. It's OK for me to read a book and not note anything or only do kindle notes. When reading articles on the net, I usually bookmark more interesting articles using getpocket. I do notes on paper when I don't want to be distracted or influenced by a computer.

For this year, my resolution is to acquire less new knowledge, but to take some time and to rehearse, summarize and repeat what I've found interesting and worth my time before. What sticks here should go into the wiki.

I want to keep my knowledge base very concise and opinionated. There's no need to create a second wikipedia.org. I'll only add something in the wiki when: * Some idea is truly remarkable on the first spot * I go over my old notes see what was the essentials of it. Those are worth putting into a wiki. * When I'm doing some dedicated, structured research around a topic. Then I also try to get the ontology and structure right first. * Code Snippets that I repeatedly use

One article that helped me to understand the OO inheritance problems understand much better is this one:

https://www.sicpers.info/2018/03/why-inheritance-never-made-...

It argues that there are three different kinds of inheritance and in OO you often mix them up into one hierachy - which may work in some situations, but in some it just can't. Personally, I've experienced this kind of conflict often enough.

Thanks for formulating this. It seems to me that there are two very diffent kind of programmer mindsets that are heavily in conflict with each other.

Some programmers want to write sophisticated (and sometimes very concise) code that requires deep understanding of the programming and sometimes reads like a "programming puzzle game" / Interview trick question.

Then there are the pragmatic types, which prefer simple code with a reductionalist approach. The code is easy to read but it is often not very generic and tends to get longer / repeated.

I can also see why Kyle Simpson doesn't like TypeScript, because it fits more the latter mindset. I've also seen competent and productive programmers of both types.

Has anyone experiences how those different approaches go together in a single team? To me it seems very difficult to come to a compromise or agreement here.

There's one point i've read somewhere that really made methink differently on this subject: It was claiming that listening to lossy formats will increase brain activity, because you're brain makes up for some missing information on thy fly. This is not a conscious proccess. But after listening to music for a while, lossless music could be less exhausting and more relaxing because of that.

Not completely sure, if this is true, I couldn't find the study for it right away.

OpenApi 3.0 is quite nice to work with. Its verbose to write by hand, though and you also need to know JSONSchema. With the Swagger UI we've had some mixed experiences. Not everything you can express in the Spec is displayed very well. But for developers, it's a nice playground / entrypoint for backend projects. We wouldn't want to miss that. (You also get this for GraphQL with the GraphQL Playground)

One of the most important features of an API Doc is that it tells the complete truth and is always up to date. An OpenApi Spec therefore really "wants" to be auto-generated. There we've had mixed experiences, aswell. If the generator is not working as expected or missing a feature important to you, you're either limited or you take on generating it yourself.

I've used an approach a while ago, I was quite happy with, but it took some effort: Everything API related has one definitite source of truth. Out of that, generate the docs, example and specs you need. Also use this for validation. For Documentation, I've used a wiki. The generated docs or code snippets were generated as Templates, and could be embedded/transcluded in the documentation, which was otherwise hand-written. This provided a nice mix of written and generated content with full flexibility.

I'm very impressed by those docs. Anyone has insights how they were made?

Looks like they were partly generated, otherwise it would be impossible to keep everything consistent - especially with the many language examples. They also seem to generate an OpenApi Spec (or use this as a basis for generating the docs?): https://github.com/stripe/openapi

I did try this a while ago (with ConEmu instead) but got into some filesystem issues when working outside of the lxss owns filesystem. You have no issues there?

Is there any decently fast and simple terminal emulator for Windows?

VSCode / Hyper 2 are GPU accellerated and are really fast once loaded. Because of their use of Electron they are not excactly fast to load, though.

So true. It also helps to have at least one person that feels ownership towards the knowledge management subject and it's systems (and builds up that culture, you're talking about). The best systems won't work well if there's nobody who puts thought into it and continually works on improving or "gardening" the knowledge system.

I have used MediaWiki for unstructured information with additional extensions for structured data (Semantic MediaWiki or Cargo) with Page Forms Extension.

This is difficult and time-consuming to setup. But if you cann afford the effort, this gives you a very flexible system where you can decide what to store in a structured or unstructured manner. Structured data can of course be queried, aggregated, vizualized etc. Together with the Page Forms extension this can replace many Excel Spreadsheets and MS Access solutions.

If you really know what you're doing, you can even do moderately complex CRUD Applications. But then you really need to know your way around several extensions and of course wikitext.

For simpler use-cases I've also used Drupal. For this use case it's not as flexible as MediaWiki, but you can do a lot through the GUI and build custom Forms / Views.

I like the curated, summarized "weekly newsletters", one of them is http://javascriptweekly.com/ but there are more.

Maybe it's just me, but I never got around liking the jQuery documentation. Its not bad - but visually too heavy, not easy to navigate and the example code is often not very consistent. Counterexample: The lodash documentation.

Sidenote: A very nice project that aggregates many API documentations and puts them into a coherent style and nice UX is http://devdocs.io/

It would be so much easier to spot fake comments or highly controversial subjects if rating systems would also show how the rating is distributed. This shouldn't be very hard to implement, too.

http://www.2ality.com/ for deeper insight in JavaScript and its current development.

A Samsung Galaxy Tab S 10.5 (2015?) with Xodo PDF Reader. The screen is very good and big enough to read and highlight/comment PDF's, even for todays standards. Xodo also saves the annotations directly back to the original PDF. Using Dropsync/Dropbox for syncing with the PC.

It's also using a simple neural network, which is the target of the genetic algorithm, if I understood it right. I haven't seen this combination often - does that make sense in general, or is this just interesting as in playing around with those concepts?

If it's an DRM free ebook I'd understand your argument. But almost all ebooks you can buy have DRM and therefore you don't really own it, you can't lend it to friends etc. It's not just about the marginal cost and the distribution cost.

https://www.rethinkdb.com/ looks very promising and also introduces some very interesting concepts and ideas.