If you paste a message from somewhere else that spans multiple lines, you can quote that without having to manually prepend > to every line!

for parsing and converting a superset of Markdown

supports standard Markdown (with some minor modifications) and various extensions that have been made popular by the PHP Markdown Extra package and Maruku

We overload the meaning of "GFM" to mean "GitLab Flavored Markdown", which is a superset of GitHub's version. However it can cause confusion as they are not the same thing.

We should ask the PM to chime in and post it in #naming on Slack.

lationship (offset) to Coordinated Universal Time (UTC). (This is distinct from some usage in scheduling applications where a local time and location may be known, but the actual relationship to UTC may be dependent on the unknown or unknowable actions of politicians or administrators. The UTC time corresponding to 17:00 on 23rd March 2005 in New York may depend on administrative decisions about daylight savings time. This specification steers well clear of such considerations.

I'm disappointed because the image for this item is misleading. It has clearly been altered to appear that the balls/marbles that come with the set are larger than they actually are. If you look closely at the picture, you can tell that the balls were digitally edited in to the original image.I have a child who still likes to chew on toys, and only purchased this for him because it appears in the image that the balls are much too large to be a risk for choking. In actuality, they're about the size of marbles and a very high choking risk.Misrepresenting this in the photo is potentially dangerous

This may be because Ubuntu 21.04 uses Wayland by default, which restricts screen recording for "security".

The dirt will sift through underneath whereas just board shoves dirt and it piles up in front of boards.

GNU cmp compares two files byte by byte and prints the location of the first difference. We can pass the -s flag to find out if the files have the same content.

pe() { for _i;do printf "%s" "$_i";done; printf "\n"; } pl() { pe;pe "-----" ;pe "$*"; } db() { ( printf " db, ";for _i;do printf "%s" "$_i";done;printf "\n" ) >&2 ; } db() { : ; }

Some people have expressed surprise end even doubt that it could be faster to read the files twice than reading them just once. Perhaps I didn't manage to explain very clearly what I was doing. I am talking about cache pre-loading, in order to have the files in disk cache when later accessing them in a way that would be slow to do on the physical disk drive. Here is a web page where I have tried to explain more in detail, with pictures, C code and measurements.

Remember the caching. Reading two files sequentially into memory from the physical disk can be faster than reading them both in parallel, alternating between them (moving the read head back and forth). Everything you do later, with all the data cached in memory, is relatively much faster. But yes, it depends on the data, and this is an average. Two files that actually do differ in the beginning will be faster to compare byte by byte.

You should mentioned what you listed after the word try_files. Here's what I ended up using that seemed to work: try_files $uri $uri/index.html $uri.html /index.html; The /index.html at the end needs to match the fallback: 'index.html' part of your adapter-static config. Otherwise going directly to a route that doesn't have a matching file at that path -- such as any route with a dynamic param like [id] -- will result in a 404.

Here's another convenient use of try_files, as unconditional redirects to named locations. The named locations are effectively acting as subroutines, saving duplication of code.

Keep in mind static here does not refer to the content on the page! Static sites can still be reactive, communicate with APIs, etc. it just means that the website package, aka the contents of the build directory that you upload to your host, doesn’t ever change.

Both solutions to insert <hr /> a horizontal line seem insane to me. You can insert nearly anything but an actual horizontal line. pray for a solution. But no actual <hr /> I can find.

The more sensible “horizontal line” htlm= <hr /> just isn’t in the program it appears.

HTML <hr> element: The prior warning is doubly important because there is a tendency to associate the term “horizontal rule” with the HTML <hr> element. LO does not generate this HTML element, either in ODT XML or when exporting to HTML, regardless of the type of horizontal rule used. This, and the preference to use styles in deference to graphic objects may also have influenced the decision to remove the Insert > Horizontal Rule… menu option and associated gallery.

However, these implicit dependencies may cause problems when running Bazel in an airgapped environment, even if you have vendored all of your WORKSPACE dependencies. To solve that, you can prepare a distribution directory containing these dependencies on a machine with network access, and then transfer them to the airgapped environment with an offline approach.

Check it out and tell us what you think. Go ahead; we’ll be here when you get back.

Narrative documentation:

Two big cons:- Can't save in the middle of a mission, and you don't know in advance how long a mission takes. (I'm too old for long playing sessions, and my kid who likes to play this with me, is too young.)

The game has no respect for your time. Saves? Nope, doesn't have them. You have to play each level through to completion in order to move onto the next one. If it had even a save and exit feature it would change my opinion dramatically.

Next, the game -does- have saves, but the devs couldn't figure out how to serialize data mid-mission and read/write a save file. "It was technically impossible due to our decision not to do it." Again, playing your game is actually not the most important thing in my life, and I don't want to spend an hour doing most of a mission only to be called away by real life and then have to start over. I get that you're apparently licensing a black-box physics engine which doesn't give you insight into its immediate state - that shouldn't matter. If you have access to the variables in memory, which you have to do for the game to run, you can serialize those variables.

It was technically impossible due to our decision not to do it."

I could love this game so easily. First off I enjoy God Games in general; Populous used to be my first exposure and remained my favourite for a long time. Secondly, the art is funky, and the creatures all make appropriate noises. Seriously, that really adds to the amount of fun I have with a game. It's also a Goldilocks game for me -- not too simple, but also not overwhelmingly complicated, so it's just right for those times when my brain isn't necessarily at its best, but I am not ready to go to bed yet, and I want something more interesting than point-and-click, yet Civilization is way too demanding.The game has a lot of options, which I also enjoy -- you can play in story mode, where you can choose from 5 different missions, starting quite easily and ending with a real challenge. Or you can play in survival mode, with 3 different difficulty options plus complete customization. It is possible to play the game 100% peacefully, no pests, no enemies, no disasters at all, which is also something I prize when I want to relax. And you can make it unbearably hard on yourself, so there's definitely a lot of replay value here.

So why am I not recommending it? I want to! The developers generally did a pretty good job, and I like to reward that, especially with so many games on Steam that are abandonware.For one, it's aggravating that the AI is not smart enough. Mims don't seek rejuvenation in their house when they most need it, especially guardians who have nothing to do but guard the place. And yet, they don't recoup their energy easily enough, which means I have to micromanage constantly. Mims who get hurt badly don't march straight for home either, and can easily die on you ("too stupid to live" comes true). I ended up choosing a custom game with only the meekest pest at a low rate of invasion simply so I could figure out where the AI fell flat on its face, and alas there are many places. And while I can micromanage rejuvenation and attacks on pests/enemies, I cannot make my Mims cut down vegetation; I have to burn it, and the burn rate is not high enough at the start to deal with the regrowth rate. That alone wouldn't cause me to recommend against a game; I'd put up with that, because it is of course its own challenge to figure out a way to win within a game's constraints. I find methodical analysis and trial building fun in its own way.

But here's the deal breaker:You cannot save in this game. And it doesn't even warn you that it doesn't auto save; when you leave, that is it, your game is gone and you have to start over. You can't set up two different scenarios, compare them, and tweak each. If you want to spend some time carefully fine tuning your game's economy, you have to basically remain logged into it for days. Which totally distorts your hours spent, aside from taking up memory from other games you might want to play or from actual work. And if your computer crashes, it's all for naught anyway. If you build a masterpiece of Mims civilization, better screen print it and then kiss it goodbye, because there is no return to old glories.So I am sorry, but I cannot recommend it. If this doesn't bother you, by all means, I think it's well worth buying even at full price, because you can get many hours of gameplay out of it if you just don't leave the game. But for me, this is a death knell for a game; I lose all interest if I can't save my work to get back to it later.

Zimbu is an experimental programming language.  It is a very practical, no-nonsense kind of language.  It mixes the good things of many existing languages and avoids their deficiencies.  And then throws in a few brand new ideas.

No option is perfect here, but a warning seems like a decent compromise unless there's a whole bunch of other plugins that break

Easy fix, but your argument cuts both ways: Many people update Vim regularly alongside their distro, but never bother to manually update their plugins.

If you had solved this any faster, it would have been in the past. Maybe going forward you can start helping us before we ask? vim-oracle plugin?

I watched some of it to help me track it down. It's offensively bad with no redeeming qualities. Shame on Netflix for streaming it.

The developer purchased Survival Engine - Crafting Building Farming by Indie Marc from the Unity store to build his game.This in itself wouldn't be a problem - that's what assets are made for, after all - but the amount of customization they put in equals to almost zero.

If you have a use case not supported by the existing public APIs, please ask and we'll be glad to add an API for you or make an existing private API public.

DatabaseCleaner.strategy = :truncation, {:except => %w[spatial_ref_sys]}

I spent some time trying to figure out why I was receiving: GetProj4StringSPI: Cannot find SRID (4326) in spatial_ref_sys From my tests. Of course SELECT * FROM spatial_ref_sys returned 0 rows.

IF NOT EXISTS (SELECT * FROM spatial_ref_sys) THEN ⋮ ANALYZE spatial_ref_sys;

depending on how the role is set up

Hi Vic, I know this post is old but was hoping to get some help here.

alter database mydb set search_path = "$user", public, postgis

Wow. I did not imagine it would be this convoluted.

The lateral keyword allows us to access columns after the FROM statement, and reference these columns "earlier" in the query ("earlier" meaning "written higher in the query").

The difference between a non- lateral and a lateral join lies in whether you can look to the left hand table's row.

The comma ( , ) in the FROM clause is short notation for CROSS JOIN . LATERAL is assumed automatically for table functions.

LEFT OUTER JOIN First, an inner join is performed. Then, for each row in T1 that does not satisfy the join condition with any row in T2, a joined row is added with null values in columns of T2. Thus, the joined table always has at least one row for each row in T1.

This latter equivalence does not hold exactly when more than two tables appear, because JOIN binds more tightly than comma. For example FROM T1 CROSS JOIN T2 INNER JOIN T3 ON condition is not the same as FROM T1, T2 INNER JOIN T3 ON condition because the condition can reference T1 in the first case but not the second.

A LATERAL item can appear at top level in the FROM list, or within a JOIN tree. In the latter case it can also refer to any items that are on the left-hand side of a JOIN that it is on the right-hand side of.

This allows them to reference columns provided by preceding FROM items.

It is often particularly handy to LEFT JOIN to a LATERAL subquery, so that source rows will appear in the result even if the LATERAL subquery produces no rows for them.

Check both execution plans (using explain (analyze, verbose) and you'll see

Why not just use a join and group by? SELECT AA.ID, COUNT(B.ID) as no_tx, min(B.DATE) as fday_tx, max(B.DATE) as lday_tx, AA.start_date, AA.end_date FROM (SELECT ID, min(DATE) as start_date, max(DATE) as end_date FROM MAIN_TABLE WHERE CODE = 'drugA' GROUP BY ID ) AA LEFT JOIN MAIN_TABLE b ON b.CODE = 'drugB' AND b.DATE > AA.start_date AND b.DATE < AA.end_date GROUP BY AA.ID, AA.start_date, AA.end_date;

window functions: SELECT ID, SUM(CASE WHEN code = 'drugB' THEN 1 ELSE 0 END) as no_tx, MIN(CASE WHEN code = 'drugB' THEN DATE END) as fday_tx, MIN(CASE WHEN code = 'drugB' THEN DATE END) as lday_tx, start_date, end_date FROM (SELECT t.*, MIN(CASE WHEN code = 'drugA' THEN date END) as start_date, MAX(CASE WHEN code = 'drugB' THEN date END) as end_date FROM MAIN_TABLE t ) t WHERE code in ('drugA', 'drugB') AND date between start_date and end_date GROUP BY t.id;

The query to the right of the Lateral would be evaluated for every row of the left table.

"People should not be afraid of their governments. Governments should be afraid of their people."

Crush up a clove and let it sit at room temperature for 15 minutes. This allows a compound known as allicin to develop - a potent anti-bacterial agent which gives garlic most of its health benefits.

A fever makes the body less favorable to viruses and bacteria for replicating, which is temperature sensitive. Our grandparents knew this, but somewhere along the line mom’s began to believe a fever was dangerous for their child and would immediately try to lower it.

When you lower your child’s temperature with medications such as ibuprofen and acetaminophen, you are hindering your child’s ability to fight the infection. A better strategy to quickly fight the infection is to raise their temperature. Or at least leave the fever be so it can do its job.

this seems a very harsh decision to remove config and page level ssr now we’ll need to add a hook for just disabling ssr

I may be talking out of place here. As all core members have agreed on this. Apologise for that.

I think there should be an easier way to declare that pages/components should not be rendered on the server. Not all client-side-only code is bad!

Having both ssr: false in handle and export const ssr = false in pages, but with those subtly different semantics, would have compounded that confusion.

It wouldn't be good design to preserve the option on the offchance that it would still be relevant if Svelte gained an as-yet hypothetical feature.

that would only be a side effect of its main purpose

main purpose, get rid of annoying errors caused by side effect imports

In order to reflect this in the types I added an Either type to the helpers, because with Union Types only the values that the types have in common are directly accessible. So it would have been necessary to first check the returned type before accessing returned properties.

It should be | { fallthrough: true } rather than | { fallthrough: boolean } I think (there's no reason you'd have false)

The combined stuff is available to components using the page store as $page.stuff, providing a mechanism for pages to pass data 'upward' to layouts.

It's always a good idea to avoid things like 'both', since it's not future-proof — if we decided we wanted to support method overrides via headers, for example (which is sometimes used to get around firewalls that disallow non-GET/POST requests), then 'both' would need to become 'all', which would be a breaking change.

I agree about documenting everything. But for me docs are a last resort (the actual text, anything beyond skimming through code examples) when things already went wrong and I need to figure out why. But we can do much better. During dev when we see _method and methodOverride is disabled we can tell the developer that it needs to be enabled. Same if we see _method with something other than POST. Same for all other cases that are currently silently ignored. If the method is not in allowedMethods arguable it should even return a 400 in production. Or at the very least during dev it should tell you. We have the knowledge, let's not make the user run into unexpected behavior (e.g. silently ignoring _method for GET). Instead let's fail as loud as possible so they don't need to open their browser to actually read the docs or search though /issues. Let them stay in the zone and be like "oh, I need to set enabled: true, gotcha, thanks friendly error message".

In contrast to fetch the only valid methods for a <form> are GET and POST. Svelte allows you to override the <form> method to workaround this limitation if you need to. That way your application can transparently work when JavaScript fails or is disabled by using fetch and <form> interchangeably with the same endpoint.

It would be great if we could keep the existing behaviour for application/x-www-form-urlencoded, but we can't, because in their infinite wisdom the web's architects decided that a regular form submission should have that content type, but a fetch with the exact same data (i.e. body: new FormData(event.target)) will have a multipart/form-data content type. In order for endpoints to behave the same way with JS-triggered form submissions as JS-less ones, we need to have consistent behaviour.

There is something nice about aligning with the platform. But it risks being a straitjacket, and I think we can provide better ergonomics when it comes to streaming.

I think this is a case where language > platform

To make finally blocks of a sync generator to be always called use appropriate form of the loop, for await...of for the async generator and for...of for the sync one and await yielded promises explicitly inside the loop.

“All your users are non-JS while they're downloading your JS”

You cannot override defaults via query parameters - this is for security reasons. The only defaults that can be overridden are dynamic segments via substitution in the URL path.

It accepts true as option, meaning it will skip all the helpers for the controllers given in :skip but it also accepts specific helpers to be skipped

I was wondering particularly whether there is a way to have a comment on the same line as the backslash

The backslash character does not concatenate any strings. It prevents the line-break from meaning that those two lines are different statements. Think of the backslash as the opposite of the semicolon. The semicolon lets two statements occupy one line; the backslash lets one statement occupy two lines.

Think of the backslash as the opposite of the semicolon. The semicolon lets two statements occupy one line; the backslash lets one statement occupy two lines.

Caution: + continues the statement but not the string. puts "foo"+"bar".upcase gives you fooBAR, whereas puts ("foo"+"bar").upcase gives you FOOBAR. (Whether or not there's a newline after the +.) But: if you use a backslash instead of the plus sign, it will always give you FOOBAR, because combining lines into one statement, and then combining successive strings into one string, happen before the string method gets called.

A key aspect of this library is its simplicity

Instead read this gems brief source code completely before use OR copy the code straight into your codebase.

It's only globally unique, so it's only unique on our planet. If you want a truly unique id you need to use a universally unique id (UUID). I assume that you're only interested in uniqueness within our universe.

Upmodded because this is the most amusing thing I've seen online today.

I'm having troubling finding anything about this question that isn't fundamentally wrong. The longer I look at it, the funnier it gets.

As a software developer, what would you say if a user came to you and said "it's not working"?

this is set 5 of 10. Previously Tyler's packs were release in sets of 50, but to help get monsters into the hands of creatives faster, he's releasing these smaller packs. When complete, there will be 10 packs in this set (80 total monsters).

Added option --uuid when generating new migration. This can be used to set the type of item_id column to uuid for use with paper_trail on a database that uses uuid as primary key.

I'm concerned that supporting certain parts of the svelte javascript semantics in module scripts—that have so far been restricted to the instance script—could lead users to believe that everything is supported. Supporting store shorthand syntax but not reactive assignments and declarations could be confusing.

Rating System: 0 = Painfully bad! Never worth watching. 1 = Bad. Only for the most dedicated fans. 2 = A mediocre episode, possibly worth skipping if new to Star Trek. 3 = Good! Generally enjoyable, worth watching if new to Star Trek. 4 = Great! An example of why we love Star Trek. 5 = One of the best. A classic.

With this YOU decide when to actually install, be it five minutes later, or the day after. (launch sudo apt upgrade from Bash/Terminal to actually install available updates)

No thanks necessary. Your up-vote and/or accepting the answer as correct by clicking on the gray check mark next to the answer and turning it green is sufficient.

I'm trying to prevent Firefox from updating in the middle of the work day. If I try to open a new tab I get "Firefox Restart Required". One of my always open tab is a Citrix connection back to a work server, and a restart tears down all those types of secure MFA sessions. One very insecure workaround is I went to Software & Updates and set the check update to "Never" and when there are security updates I only download and will update when i remember to do so. This is what Windows used to do many years ago, when you had to restart the OS at inconvenient times. So they are forcing us to restart the browser to keep secure, but folks like me are forced to manually update. Is there a way to disable the "Firefox Restart Required" without disabling all security updates?

Note though that restarts are an essential part of updating software, by refusing to restart when you apply an update you are risking having a less stable software running as well as postponing what could be security updates and putting yourself at risk. There is a reason software asks for restarts and you absolutely should respect that.

Not saying that occasionally there isn't a "feature only" release, but 99% of the time, the updates have fixes and many times they are of a critical security nature. FF, like others, has a responsibility and lawsuits to avoid.

Yeah, without JS the internet is quite unusable today sadly. I suppose a lot of sites make JS mandatory because it allows better tracking and stuff like this. I hate it. So disabling JS completly via about:config is not a solution.

> So disabling JS completly via about:config is not a solution. It is. Works for me (yes, no NoScript, the real thing). My main Firefox profile is like that, then I have a secondary profile for the cases I really need it for — that gets used less than once a month. Oh, and no cookies either. Luckily, hackaday works fine like that (even cookieless commenting: big kudos and thanks! That’s why I keep returning here). And LWN (I temporarily enable cookies to post), and more than 95% of the sites I care about. As it turns out, I care less and less for the other 5%: so this number is actually shrinking.

So to Nay, upthread: leading by example here. Want to follow? :)

I fully agree the best solution for security is “javascript.enabled = false”

Lets go back to the original “browser as a document” instead of “browser as OS”.

As I said up-thread, it was promised from Day 1 that browsers would always execute client-side Javascript safely. That was central to its acceptance.

You don’t need microsecond timing on a freaking website – except maybe in graphics and sound, and such functionality could be wrapped and secured in an API. So think that browser makers deserve a bigger slice of blame for making their users so vulnerable. User safety needs to become important again.

Somehow this seems sad, to have to be forced to have computers run fuzzy time because of buggy hardware and nasty abusers of such.

They coincide in most cases, but they don't if there are series of consecutive uppercase letters as in "HTMLParser"

Making MoneySerializer reloadable would be confusing, because reloading an edited version would have no effect on that class object stored in Active Job.

Indeed, if MoneySerializer was reloadable, starting with Rails 7 such initializer would raise a NameError.

Let's imagine your project talks to databases, supports several, and has adapters for each one of them. Those adapters may have top-level require calls that load their respective drivers: # my_gem/db_adapters/postgresql.rb require "pg" but you don't want your users to install them all, only the one they are going to use.

In that line, if two loaders manage files that translate to the same constant in the same namespace, the first one wins, the rest are ignored. Similar to what happens with require and $LOAD_PATH, only the first occurrence matters.

Think the mere existence of a file is effectively like writing a require call for them, which is executed on demand (autoload) or upfront (eager load).

It is very important that your gem reopens the modules ActiveJob and ActiveJob::QueueAdapters instead of defining them. Because their proper definition lives in Active Job. Furthermore, if the project reloads, you do not want any of ActiveJob or ActiveJob::QueueAdapters to be reloaded. Bottom line, Zeitwerk should not be managing those namespaces. Active Job owns them and defines them. Your gem needs to reopen them.

There are project layouts that put implementation files and test files together.

Note that since the directory is ignored, the required adapter can instantiate another loader to manage its subtree, if desired. Such loader would coexist with the main one just fine.

Kernel is already defined by Ruby so the module cannot be autoloaded. Also, that file does not define a constant path after the path name. Therefore, Zeitwerk should not process it at all.

Let's suppose that your gem decorates something in Kernel:

This inflector is like the basic one, except it expects lib/my_gem/version.rb to define MyGem::VERSION.

Zeitwerk raises Zeitwerk::UnsynchronizedReloadError if any of these situations are detected. This is a fatal exception that signals a fundamental bug, you cannot rescue it and expect things to work.

All known use cases of require_dependency have been eliminated with Zeitwerk. You should grep the project and delete them.

if Rails.application.config.reloading_enabled? Rails.autoloaders.main.on_unload("Country") do |klass, _abspath| klass.expire_redis_cache end end

You need to tell the main autoloader to ignore the directory with the overrides, and you need to load them with load instead. Something like this: overrides = "#{Rails.root}/app/overrides" Rails.autoloaders.main.ignore(overrides) config.to_prepare do Dir.glob("#{overrides}/**/*_override.rb").each do |override| load override end end

If your application decorates classes or modules from an engine,

Every element of config.autoload_paths should represent the top-level namespace (Object).

would define a Views module, for example, as an unwanted side-effect.

Some projects want something like app/api/base.rb to define API::Base, and add app to the autoload paths to accomplish that.

By default, app/models/concerns belongs to the autoload paths and therefore it is assumed to be a root directory. So, by default, app/models/concerns/foo.rb should define Foo, not Concerns::Foo.

# config/initializers/zeitwerk.rb ActiveSupport::Dependencies. autoload_paths. delete("#{Rails.root}/app/models/concerns")

Doing so affects how Active Support inflects globally. That may be fine, but if you prefer you can also pass overrides to the inflectors used by the autoloaders:

Once zeitwerk mode is enabled and the configuration of eager load paths double-checked, please run: bin/rails zeitwerk:check

the last "All is good!" is what you are looking for.

To verify the application is running in zeitwerk mode, execute bin/rails runner 'p Rails.autoloaders.zeitwerk_enabled?'

it is highly encouraged to switch to zeitwerk mode because it is a better autoloader

Much of this sort of information was later reverse-engineered, and cross-browser support for basic operations is actually quite good. (Browsers still vary widely on the details.)

Reverse-engineering and standardizing contentEditable

A brief and extremely biased timeline of standardization

export RUBY_THREAD_VM_STACK_SIZE=2000000

This is not a path I'd recommend for small-to-medium-sized teams, but if you're inside a large organization committed to making SPAs with high walls between front-end and back-end departments, it might make sense.

Stimulus is a JavaScript framework with modest ambitions. It doesn’t seek to take over your entire front-end—in fact, it’s not concerned with rendering HTML at all.

We're moving forward by taking things out.

We're way overdue a correction back to simplicity for the frontend. ES6/HTTP2/Import maps looks like they'll deliver just that.

Unless new evidence comes to bear that refutes the basic tenets of this analysis

Rails 7.0 will aim to give you a default setup based on import maps, and leave the Webpacker approach as an optional alternative.

The final piece that's pushing the two first crucial changes over the paradigm hill is import maps. They allow the use of logical references for modules in ES6 (also known as ESM), rather than explicit file references.

Five years later, the facts on the ground have finally changed. I no longer believe that this bargain is worth it for most new applications.

Transpiling with Babel ushered in the era of horrendously complicated transpiling pipelines and tooling. Writing the JavaScript of the future wasn't free. The price was an ever expanding web of complexity. This clearly wasn't the finish line.

Today, many web developers are even using JavaScript's native module syntax, but combining it with bare import specifiers, thus making their code unable to run on the web without per-application, ahead-of-time modification. We'd like to solve that, and bring these benefits to the web.

For now, we'll concentrate on the semantics of the mapping, deferring the installation discussion.

The heart of Hotwire is Turbo. A set of complementary techniques for speeding up page changes and form submissions, dividing complex pages into components, and stream partial page updates over WebSocket. All without writing any JavaScript at all. And designed from the start to integrate perfectly with native hybrid applications for iOS and Android.

It feels great to get an email from someone you care about. Or a newsletter you enjoy. Or an update from a service you like. That’s how email used to feel all the time.

Email gets a bad rap, but it shouldn’t. Email’s a treasure.

Now email feels like a chore, rather than a joy. Something you fall behind on. Something you clear out, not cherish. Rather than delight in it, you deal with it.

HEY’s fresh approach transforms email into something you want to use, not something you’re forced to deal with.

Email sucked for years. Not anymore — we fixed it.

The core benefit of Marginalia is being able to decorate SQL queries with details of the context of the source of the query.

d