I thought him very plain at first, but I do not think him so plain now

// Native const datePattern = /^(\d{2})-(\d{2})-(\d{4})$/; const [, month, day, year] = datePattern.exec('12-25-1995'); new Date(`${month}, ${day} ${year}`);

The consumer component will barely change from our last example. The only difference is the way we'll get a reference to our store (since now the store is exported from the JS module):

Now your whole WS logic can be encapsulated in your JS module. That makes for good separation of concern.

Stores are the idiomatic Svelte way when you need to import "reactivity" from your normal JS sources.

Ideally, GitHub would understand rich formats

One part of React that I've always championed is how it's just JavaScript. I like that in React you don't use a distinct template syntax and instead embed JavaScript, compared to Svelte's templating language

I will always find React's approach easier - at least in my head - and I think more friendly to people familiar with JavaScript who are learning a library.

Another important MicroJS attribute is independence. Ember, Backbone—even Bootstrap to a degree–have hard dependencies on other libraries. For example, all three rely on jQuery. A good MicroJS library stands by itself with no dependencies. There are exceptions to the rule, but in general, any dependency is another small MicrojJS library.

D3 now passes events directly to listeners, replacing the d3.event global and bringing D3 inline with vanilla JavaScript and most other frameworks.

Last week, I shared how to check if an input is empty with CSS. Today, let’s talk about the same thing, but with JavaScript.

You can do and impressive amount of form validation with just HTML attributes. You can make the user experience pretty clean and clear with CSS selectors.

the client form validation is the one I like a lot, because, for example, by adding required attribute to an input, I don’t need to write any additional JavaScript to warn a user, when the user submits a form without filling out the required fields

function isObject(o) { return o instanceof Object && o.constructor === Object; }

An array is from a logical point of view not an object - although JavaScript handles and reports them as such. In practice however, it is not helpful to see them equal, because they are not.

Arrays are definitely objects. Not sure why you think objects can't have a length property nor methods like push, Object.create(Array.prototype) is a trivial counterexample of a non-array object which has these. What makes arrays special is that they are exotic objects with a custom [[DefineOwnProperty]] essential internal method, but they are still objects.

arrays are not objects from a logical point of view. I'm speaking about program logic. It is sometimes necessary to check if an array is a "real" array and definitely not an "real" object. That's what Array.isArray() is for. Imagine you have a function which accepts an object or an array of objects.

function isObject (item) { return (typeof item === "object" && !Array.isArray(item) && item !== null); }

while Fascism died in 1945 with the collapse of the Axis powers

that first began in the United States

But the people do not directly exercise their sovereignty, for instance, by voting directly in popular assemblies.

The first was the sundering of civil from religious law with the advent and widespread adoption of Christianity.

to write the document which we have today.

The second momentous change was the emergence of multiple denominations within Christianity that undid Christian unity and in turn greatly undermined political unity.

My frustration is mainly from Svelte's choices that are very un-JavaScript-like. It doesn't have to be "like React/Vue". React is React because it doesn't restrict what you can do with JavaScript for the most part. It's just common FP practice to fold/map.

Remember that "JavaScript" does not mean that the DOM API, AJAX, HTML5 <canvas> (and so on) are available - it just means the JavaScript scripting language is being used - that's it.

You can set options.params to a POJO as shown above, or to an instance of the JavaScript's built-in URLSearchParams class. const params = new URLSearchParams([['answer', 42]]); const res = await axios.get('https://httpbin.org/get', { params });

Checking if an object is a POJO can be somewhat tricky and depends on whether you consider objects created using Object.create(null) to be POJOs. The safest way is using the Object.getPrototypeOf() function and comparing the object's prototype.

The intuition behind POJOs is that a POJO is an object that only contains data, as opposed to methods or internal state. Most JavaScript codebases consider objects created using curly braces {} to be POJOs. However, more strict codebases sometimes create POJOs by calling Object.create(null) to avoid inheriting from the built-in Object class.

If the react cargo cult didn't have the JSX cowpath paved for them and acclimated to describing their app interface with vanilla javascript, they'd cargo cult around that. It's really about the path of least resistance and familiarity.

Why not just use that instead of inventing a syntax that's not part of ECMAScript?

One of the arguments that's frequently deployed in favour of JSX-based frameworks over template-based ones is that JSX allows you to use existing language constructs:

clean and understandable markup template without the help of 3rd party

I really do not like writing templates in a file, such as #each , #if. I do not like to prefer using new approaches for which i can do it with purely in JavaScript.

This starter takes advantage of Typescript and Emotion. This is a personal choice, and I'd encourage you to give it a shot. If you're interested in using plain ES6 and regular scss styling, see release v1 of this library.

Its superior not because its faster, nor because there are shortcuts for you to do things, but because you can make shortcuts to do things.

Your task list is a plain text file, not some proprietary format owned by a company or locked to a specific application.

A simple and timeless format Plain text is the simplest file format there is. It will always be accessible, by some kind of application, forever.

Plaintext files are tiny, simple, quick to work with, editable by tons of great programs, searchable by all modern operating systems, easy to back up, perfect for versioning, trivial to sync between devices, and are amazingly flexible in their uses and formats.

In this system, plaintext files are used for most of the backbone of your organizational system.

made to work alongside the various plain-text, Dropbox syncing mobile notes apps such as Denote for Android and Jottings for iPhone from an app for the Ubuntu desktop. Plain text notes anywhere you want. Easily synced between your desktop and phone. Notes, plain and simple.

Future proofs your journal entries by saving them as plain text and organizing them as you go. This means you can read or create entries when you don’t have DayJournal.

It’s flexible in precisely the way so many modern apps aren’t, and if you like tweaking things until they’re just right, I can’t recommend it enough.

And if all else fails, you can just use a text editor.

The file contents should be human-readable without requiring any tools other than a plain text viewer or editor.

A user can manipulate the file contents in a plain text editor in sensible, expected ways. For example, a text editor that can sort lines alphabetically should be able to sort your task list in a meaningful way.

Plain text is software and operating system agnostic. It's searchable, portable, lightweight, and easily manipulated. It's unstructured. It works when someone else's web server is down or your Outlook .PST file is corrupt. There's no exporting and importing, no databases or tags or flags or stars or prioritizing or insert company name here-induced rules on what you can and can't do with it.

We found that a plain language summary gives readers an instant overview of an article, making it easier to understand and also easier to find.

Translation apps continue to leave much to be desired.