denisw

VS Code and Atom are based on Electron, which is a platform by GitHub using the Google Chrome browser engine, which was forked off Apple‘s WebKit engine, which was forked off KHTML from the KDE project.

It‘s great to know that native .gitignore support is being considered! Definitely looking forward to that. :)

Sublime Text is a really nice and performant text editor, but one thing I unfortunately just can't get past is how excluding files from fuzzy-finding (Cmd+P) is handled. Files like .gitignore are not respected, so I need to kinda-replicate what is in .gitignore for every project in Sublime-specific project files. I thought I'd write a plugin for that, but it's not even possible to completely model .gitignore exclusions using Sublime's system because that's not powerful enough [1]. Lastly, excluded folders and files are removed _completely_ from the sidebar instead of, say, being greyed out like in Atom or VS Code. This means that if I do need to look into, say, a file inside node_modules/, I have to open it through other means.

[1]: https://forum.sublimetext.com/t/make-include-exclude-pattern...

Try Framer [1]. You're still designing in code, but using a tool that "wireframe" designers can more easily understand and appreciate. Might help with the interviews. :)

[1]: https://framer.com/

Code reviews. Let developers peer-review each other's code changes and share knowledge about the functional programming practices used in the codebase. This is not a technical problem and has nothing to do with Scala.

> There's no really universally applicable way of just going "show me all the code that processes annotation X" to your IDE

Isn't "Find References" literally that? All code that makes use of an annotation at runtime (which is the case for all Spring annotations) needs to refer to the annotation's type at some point.

They did for 1.x, retroactively. That line of versions is now referred to as AngularJS by the Angular team, while the name Angular is reserved for 2.x and up.

> success typing puts the burden of proof on the compiler which will only reject a program if it can prove that the program is incorrect [1]. But as far as I know, that approach has not been included in any mainstream programming languages.

Dialyzer, the optional static typing system that is of part of the Erlang distribution, is based on success typing. Here is an accessible introduction:

http://learnyousomeerlang.com/dialyzer

Service Workers (which are one of the core technologies behind the Progressive Web Apps label) go further than manifest files because they can deal with any kind of HTTP request (including e.g. calls to your REST API). Also, because they are code rather than static lists backed by hard-wired browser logic, you can implemnt any kind of caching strategy you want.

That being said, Progressive Web Apps is pretty much just an umbrella term useful for marketing several new and upcoming browser APIs (Service Workers being one of them) and not really a thing in itself.

They work offline, and can do background tasks such as showing notifications even while the app is not open (enabled by Service Workers).

They are not _different_ from what iOS offers, they just take things to the next level.

It's your problem if a third of your potential users gets put off by how sub-standard your PWA is on their platform and chooses a competitor with native mobile app instead.

One important argument against this practice is that node_modules is usually not cross-platform. It's likely that somewhere within your dependency graph, there is a package that contains native code, which results in platform-specific binaries in your git repository.

You don't need VM support for tail self-calls (which is exactly what Clojure supports with `recur`), but you sure do for optimizing tail calls to other functions. There is no way in the JVM to say "replace my stack frame with a new one for that other method and execute that", especially not one that gives you a useful stacktrace for debugging.

Context for those who haven‘t played Skyrim: http://knowyourmeme.com/memes/i-took-an-arrow-in-the-knee

It seems as if the author is on the way to rediscovering the idea of Unobtrusive JavaScript, aka the RSJS pattern (Reasonable System for JavaScript):

http://ricostacruz.com/rsjs/

The main difference is that Unobtrusive JavaScript relies on HTML5 data attributes rather than misusing CSS classes.

Perhaps the most well-known example of the Unobtrusive JavaScript approach are the AJAX helpers of Rails:

http://guides.rubyonrails.org/working_with_javascript_in_rai...

I think spankalee meant NPM packages being distributed as ES6 modules rather than ES5 source files that use require() or are pre-bundled with something like Webpack or Rollup (as is the case for many frontend packages). Node.js has support for ES6 modules since version 8.5.0 [1], so this will slowly become feasible.

[1]: http://2ality.com/2017/09/native-esm-node.html

To expand on that, there is no “beta“ channel, just a channel per release. If you install 17.10 beta, you‘ll get 17.10 package updates until the day of release, at which point you have the set of package versions that are considered the „stable“ release. After that, the 17.10 channel gets post-release bug and security fixes only.

Unfortunately, the VS Code Java plugin doesn't have support for this yet. Here is the corresponding GitHub issue, which however hasn't seen much activity:

https://github.com/redhat-developer/vscode-java/issues/56

The most popular framework that fits this description might be Pyramid [1].

[1]: https://trypyramid.com/

This advice makes no sense for GraphQL, which is a _protocol_ rather than a piece of software. In fact, the perhaps most-used GraphQL implementation these days (Apollo) is not written by Facebook and is purely MIT-licensed.

Of course, you do need to ask yourself these legal questions if you use Relay.

Ubuntu has probably emulated macOS here, which translates the Desktop as "Schreibtisch" as well.

Could you explain which changes to Elixir 1.5 and OTP 20 should result in better Dialyzer error messages? I didn't find anything relevant to that in the respective changelogs.

(For context, Dialyzer is a static analysis tool detecting type errors which is part of the core Erlang distribution.)

I agree about /actions, it is unnecessary. However, for these kinds of "action resources", POST is definitely the best-matching request method. It does not mean "create a resource" (although this is one case it is often used for), but "process this request in your custom resource-specific way". The HTTP RFC formulates it like this [1]:

> The POST method requests that the target resource process the representation enclosed in the request according to the resource's own specific semantics.

Given that what an action resource does is, by definition, resource-specific, POST fits perfectly.

[1]: https://tools.ietf.org/html/rfc7231#section-4.3.3

Unless you are writing an app that should also work offline. In this case, most of your logic _must_ be your frontend, and your backend is mostly a data repository for data backup and synchronization. In such a scenario, database-as-an-API seems to be exactly the right approach.

Given the title, it seems that this should rather link to the framework itself (https://github.com/picoe/Eto).

styled-components works fine with unejected create-react-app, I use this combination all of the time. Server-side rendering would probably still need ejecting, though, for access to the Webpack and Babel configuration. Same for hot module replacement, which in create-react-app is only enabled for CSS files as far as I know.

Yes. The iPhone 5 has received iOS 10, so it can run all iOS 10 apps in their most recent versions. There are some (mostly hardware) features that iPhone 5 users don't have access to (e.g. 3D Touch) so they might not be able to use all power features, but that doesn't prevent you from using the complete fully updated app catalog.

As an iPhone 5S user, I don't feel like I'm disadvantaged at all from having a phone that is three generations behind.

> - uses [ and ] for subexpressions instead of ( and ), which makes typing easier

I would like to point out that in several non-US keyboard layouts, [ and ] are harder to type, not easier. For instance, on German keyboards, they are mapped to Right-Alt (AltGr) + 8/9, which is quite annoying to type compared to normal parentheses (which are mapped to Shift+8/9, with Shift being better placed and available on both the left and right side of the keyboard).

> I wish there were more community-provided types for flow.

One technical limitation that complicate contributions to the flow-typed repository is that there is no way of writing typings that depend on other libraries' types [1]. For instance, flow-typed has a library definition for `rxjs`, but it is not possible to e.g. add a definition for `redux-observable` that reuses the RxJS `Observable<T>` type, because there is no way to express that the typings of `redux-observable` neeed the ones of `rxjs` to function. So typings for such closely related libraries tend to not exist in flow-typed.

To work around this problem, some libraries like styled-components require you to manually include the library definition files it requires in your `.flowconfig` [2], but this is a rather hacky workaround.

[1]: https://github.com/flowtype/flow-typed/issues/16

[2]: https://github.com/styled-components/styled-components/blob/...

It seems as if the Ionic team is planning to support the desktop in the fuure:

> Coming next we are working on new features to add proper desktop and electron support, something we’ve dipped our toes into in the past but will be making a bigger priority going forward.

That being said, there is Electron, but that "only" provides you with the runtime to run a web app as a natively integrated desktop app, not with visual components and the like.