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

Niemand liest Rezensionen, also sag ich einfach mal dass ich schwul bin!

All that can be forgiven, but not charging $10 USD for this bundle worsener (they dumped it very quick into shovelware game bundles). $10 gets you a lot of great games on Steam like Frostpunk, Metro and Skyrim, so it's impossible to ask anyone considers this against the competition.

I get it, game development is hard, not everyone gets to be an astronaut, you must be this tall to take the ride.

what looks like a Unity Asset Store flipped robot

Boston AInamics (an unauthorised riff on the name of the robotics company, Boston Dynamics, I hope they sue)

Grundsätzlich eine nette Idee. Aber an der Umsetzung hapert es. Mein Roboter stößt manchmal gegen unsichtbare Wände oder wird plötzlich in die Luft geschleudert. Zudem wird das Spielprinzip aufgrund der eingeschränkten Bewegungsmöglichkeiten und der immer gleichen Texturen sehr schnell langweilig.

_refs.filter(Boolean)

let _refs = [] $: refs = _refs.filter(Boolean)

It is best practice not to use user input to dictate where your app is going to redirect, this is highly exploitable.

Update 2 - I have confused myself as well.

I found something wired! I had a target=blank in my kindergarten.svelte file that when I click on a link that opens in a new tab , in that tab when I click on other links page doesn't load without refresh! It's a little bit confusing !

In fact, "stuff" was a better name. If I said "put it in the context", there were like 15 things in the codebase called "context", but "put it in stuff", well, there's only one thing called "stuff". Because no one else was brave/silly enough to use that name.

I suppose most systems use a word like "context", "environment", "data", "info", "headers", "metadata"... but those words really aren't any more descriptive, now are they! They are just stuff!

Loading in, receiving, and/or passing cargo

Synonyms include bequest and primogeniture, which are both wonderfully ridiculous suggestions

The drawback of a few more keystrokes is a hit I'll gladly take.

Since context just fits best if it wasn't taken already, I propose layoutContext or loadContext to show a) the semantic similarity to contexts but b) make it visible that this is different and belongs to a specific part.

inherit inherits inherited pipe chain context (keep as is) locals (again) tunnel metadata env scene domain foo $layout

payload bag obj

yield, present, furnish

isn't ideal but it sort of works if you squint

Some ideas that were floated, in no particular order of terribleness:

I tried mapping out the different flow of information for the two different contexts:

it's the fact that Microsoft hasn't prioritized this work. There's nothing magical about Blink or V8 that makes the Chrome password manager better than Edge's; it's just that Google has taken the time to do the work.

Will be executed right after outermost transaction have been successfully committed and data become available to other DBMS clients.

(I can't imagine use case for it but if you can, please open a pull request or issue).

after_commit { puts "We're all done!" }

We're all done!

I'm a big fan of refinements (yes, I am), and that's what I did to make this code look simpler and more beautiful:

These callbacks are smart enough to run after the final (outer) transaction* is committed. * Usually, there is one real transaction and nested transactions are implemented through savepoints (see, for example, PostgreSQL).