indentit

I agree that qualities like "fast"/"performant" are intentional, and are thus prominently displayed in the project's readme, but are qualities like "maintainable" often found as a stated goal in readmes?

Or if the readme doesn't mention such qualities, can one assume that if it isn't deliberately fast etc. then it is likely to be maintainable because that quality hasn't been sacrificed for a different one?

I'm tempted to say no because not all developers necessarily have the experience to ensure their code base is easily maintainable, but assuming the developer(s) do have experience in writing clean code, is it then safe to assume it [is maintainable]?

It drives me crazy when I read fiction books which use Fahrenheit (and sometimes don't even specify units) as I don't understand that measurement or many other imperial units at all. One would think in this day and age that authors could use some semantic markup and one's e-reader could use the reader's preferences to format the book for easier understanding/comprehension

this isn't anything new - see CarWink[1] from 2 years ago for example. I didn't become a backer of that kickstarter iirc because one couldn't make their own graphics or translate the text for non-English speaking countries etc.

[1]: https://www.kickstarter.com/projects/503429569/carwink-makin...

I think its fair to say that the results of this paper/study are entirely unsurprising.

Yes, there are differences in how different regex engines work - anyone that has ever used regular expressions in more than one programming language will already know it. Yes, this impacts what text matches and performance.

And yes, many programmers don't care or don't want to waste time on it (be it learning regex properly or thinking about a suitable expression for their requirements) and so just copy and paste expressions from elsewhere without caring too much about compatibility or performance. (Sometimes it is justified - "don't reinvent the wheel" and "premature optimization" and all that.)

I personally don't think we needed a paper or study to tell us this, but if it raises awareness, then I guess its a good thing :)

These days I tend to use the built in element inspector instead to view live state, unless I specifically want to see the original state - from before JS got involved :)

sounds interesting, is the development of that something joe public can look at? :)

Agreed, and it is indeed possible to have "context coloring" with normal, useful syntax highlighting alongside it - subtly lighten or darken the background color when going down a scope level into a nested function etc.

How many people would know what caused it, though? Maybe they spent a while on a few different websites, but only one was a resource hog...

A paid, Mac only app which could fairly easily be implemented as a plugin to any popular text editor... I'm not sure I understand the appeal - what am I missing here, please? :)

PowerShell Core / 6 is cross platform...

Most compilers skip optimizations when compiling in debug mode, so that it is still quick to iterate/test, then perform the optimizations which take longer to compile for release builds. Obviously it means one can only profile code when it has been compiled in release mode, which I guess has its drawbacks...

This article is mainly about performance improvements, so I guess GitKraken wanted to remain competitive since Sublime Merge was released. But not being able to use it for private repos (sometimes I work on a project I plan to release as open source in private until I'm ready for the world to see it) without paying yearly is potentially a deal breaker for some, no?

Modern debuggers generally support conditional breakpoints, but they often incur a high performance penalty, so this reasoning makes sense to me.

As someone that commutes 80 km to work every weekday (i.e. one way) in a country where its the law to change tyres twice a year and the usual recommendation for oil changes are after every 10 or 15 thousand kilometers, I think its safe to say that your statement can't be applied generally even if its true for you...

> A little more than 12 years ago, building and hosting a website was a serious undertaking, costing thousands, and requiring many experts.

Certainly not - any teenager could do it alone even more than twelve years ago. I remember using Notepad - before syntax highlighting was really a thing - to build a site in PHP and hosting it with Apache. The only cost was the domain registration fee.

There are lots of references to "cross platform" on the page, so it seems that the answer is likely yes (without having signed up for the beta myself to fully confirm).

Unless this new OS will be open source, I see no reason for anyone to trust it. There have been many other mobile OSes and they have all failed really...

Was this perhaps inspired at all by the Materialistic Hacker News app for Android? It has most of those features you listed :)

I wonder if it will be a permission users can see an app has before installing for the first time or updating to a version that includes this "feature". I guess one will have to be even more careful deciding to purchase any apps, and make backups of apks so one can restore a previous known working version without the forced auto updates...

well obviously the default should be Python 3, but I guess no default is better than a default of Python 2. I like that they separated the "user-space" Python from what the bundled tools use as a dependency.

not in this universe they aren't - many popular applications indent 4 spaces by default when pressing the Tab key, and render physical tabs as four spaces, for example github ;) tabs of 8 space width are a legacy travesty that wastes space :)

I like the uniform output, nice work!

I personally think its easier to use something like the `sublime-syntax` grammar format to define a lexer (with a project like syntect[1]), rather than implementing each language's lexer as code, but that would need some extra annotation to get such a nice structured output. The bonus, however, if someone where to work on such an addition, would be that syntax highlighting will use the same engine and deal with incomplete/incorrect code consistently

[1]: https://github.com/trishume/syntect

is it somehow related to "mixed mode assemblies"[1]?

[1]: https://github.com/dotnet/coreclr/issues/18013

Ooh, instructions as to how would be super, please :)

yes, it can be unintuitive, but single newline ignorance has its advantages too, for example one can make semantic line breaks[1] for easier diffability.

[1]: https://sembr.org/

Perhaps you could explain that a bit more, please? AFAIK, HTML's "<ol><li>" tags work just fine, as does Markdown's "1." syntax...

I guess this isn't so relevant now that CommonMark and GFM specs and reference parser implementations exist, though I know they don't cover some fairly popular things like footnotes from "markdown extra"...

This is super exciting for me, as a C# developer. I'm fed up of needing (to learn how) to compile C++ projects for each platform so that I can reference them from .NET Core. The idea of just compiling them once for WebAssembly/WASI and only needing to ship one copy of each binary dependency is quite freeing and makes cross plat functionality easier.

I'm just getting a 404 from Medium here...

I personally don't like hard wrapping the body of a commit message because it then looks terrible every where - GitHub website, git client etc. and it becomes much harder to read