If tech doesn’t contribute to solving some of the problems it creates, we are doomed

The "Dokkōdō" (Japanese: 獨行道) ("The Path of Aloneness", "The Way to Go Forth Alone", or "The Way of Walking Alone") is a short work written by Miyamoto Musashi a week before he died in 1645. It consists of 21 precepts. "Dokkodo" was largely composed on the occasion of Musashi giving away his possessions in preparation for death, and was dedicated to his favorite disciple, Terao Magonojō (to whom the earlier Go rin no sho [The Book of Five Rings] had also been dedicated), who took them to heart. "Dokkōdō" expresses a stringent, honest, and ascetic view of life.

no we don't

Shared links offer a new way for users to share their ChatGPT conversations, replacing the old and burdensome method of sharing screenshots.

Stop to think about "normal app" as like desktop app. Android isn't a desktop platform, there is no such this. A "normal" mobile app let the system control the lifecycle, not the dev. The system expect that, the users expect that. All you need to do is change your mindset and learn how to build on it. Don't try to clone a desktop app on mobile. Everything is completely different including UI/UX.

We have a finite pool of good will with which we can advocate for the implementation of new security technologies. If we spend all that good will on irritating attackers, then by the time we’re ready to actually implement a solution, developers are not going to be interested.

When you call 'foo' in Ruby, what you're actually doing is sending a message to its owner: "please call your method 'foo'". You just can't get a direct hold on functions in Ruby in the way you can in Python; they're slippery and elusive. You can only see them as though shadows on a cave wall; you can only reference them through strings/symbols that happen to be their name. Try and think of every method call 'object.foo(args)' you do in Ruby as the equivalent of this in Python: 'object.getattribute('foo')(args)'.

from the start the logic reflected the social relations of the one-way mirror. They were able to see and to take — and to do this in a way that we could not contest because we had no way to know what was happening.

Diet YAML is a light weight version of YAML that removes much of the complex aspects of the mainline YAML specification.

The best way to learn common table expressions is through practice. I recommend LearnSQL.com's interactive Recursive Queries course. It contains over 100 exercises that teach CTEs starting with the basics and progressing to advanced topics like recursive common table expressions.

This can lead to the sending of email to the correct address but the wrong recipient.

two-way links

How Large Is A Note?

So far for the obligatory warning. I get the point, I even agree with the argument, but I still want to send a POST request. Maybe you are testing an API without a user interface or you are writing router tests? Is it really impossible to simulate a POST request with Capybara? Nah, of course not!

While there are many great answers regarding the "glyph not found" glyph, that won't help you actually detect it, as the text string in code will still have the character regardless of the font used to render it.

This breaks the TIMTOWTDI rule

I'm afraid you missed the joke ;-) While you believe spaces are required on both sides of an em dash, there is no consensus on this point. For example, most (but not all) American authorities say /no/ spaces should be used. That's the joke. In writing a line about "only one way to do it", I used a device (em dash) for which at least two ways to do it (with spaces, without spaces) are commonly used, neither of which is obvious -- and deliberately picked a third way just to rub it in. This will never change ;-)

The language was designed with this idea in mind, in that it “doesn't try to tell the programmer how to program.”

This motto has been very much discussed in the Perl community, and eventually extended to There’s more than one way to do it, but sometimes consistency is not a bad thing either (TIMTOWTDIBSCINABTE, pronounced Tim Toady Bicarbonate).[1] In contrast, part of the Zen of Python is, "There should be one— and preferably only one —obvious way to do it."

The bash manual contains the statement For almost every purpose, aliases are superseded by shell functions.

the AST version of the code is vastly superior IMHO. The knowledge about what constitutes an access modifier is already encoded in the system so it makes more sense to just call the method to test the type of node. The regexp solution may be expedient, but it's not as resilient to change -- if new access modifiers are added in the future it's very likely this code won't be updated, which will be the source of a bug.

It's a great way to test various limits. When you think about this even more, it's a little mind-bending, as we're trying to impose a global clock ("who is the most up to date") on a system that inherently doesn't have a global clock. When we scale time down to nanoseconds, this affects us in the real world of today: a light-nanosecond is not very far.

Interestingly, Rails doesn't see this in their test suite because they set this value during setup:

Dogen and Nagarjuna’s Tetralemma #6 of 21

THE LOGIC OF THE CATUSKOTI

let me first say how why we're here um 00:05:01 and first point out that barry and carl have never met before this is the first time you will discuss

All seem focused on rendering the 404 page manually. However, I wanted to make rescue_from work. My solution is the catch-all route and raising the exception manually.

Best Ways to Scale a Startup or Business Successfully

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

The Internet owes its strength and success to a foundation of critical properties that, when combined, represent the Internet Way of Networking (IWN). This includes: an accessible Infrastructure with a common protocol, a layered architecture of interoperable building blocks, decentralized management and distributed routing, a common global identifier system, and a technology neutral, general-purpose network.

and within that within that area then you have on one on the light side with on the eastern side of the milky way all of those people there have a 00:39:56 relationship to each other all the tribes and all the clans and so and then you come on to the west side exactly the same thing again so on the east side those stars on the 00:40:10 bright side we are not allowed if you've got a totemic system that belongs to the east side you cannot marry your children into any one of them you must marry across the river so 00:40:23 you've got to go across the river which is that milky way and so the light side's going to go across the dark side to find their wives and so the old people understood who the people were and 00:40:35 and so they understood that genealogical background of every family every child and so they made sure that that when you made a promise to a child you 00:40:49 make sure that there are at least five generation removed from the people you want to marry them back into genetics was very important to us even though we didn't know it was genetics at 00:41:01 the time but it was maintaining the purity of the people

dark constellations

Replaces your Rails controllers, views and forms with meta programming. Considers routes.rb, ability.rb, current_user and does the right thing.

his suggests that successful problem solvingmay be a function of flexible strategy application in relation to taskdemands.” (Vartanian 2009, 57)

No, United Way isn’t sitting still—it recently teamed up with Salesforce.org to roll out a new app called Philanthropy Cloud. For now, however, upstart Benevity rules the online workplace giving space.

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

I am firmly convinced that asserting on the state of the interface is in every way superior to asserting on the state of your model objects in a full-stack test.

Even if #foo is originally on the page and then removed and replaced with a #foo which contains baz after a short wait, Capybara will still figure this out.

As long as you stick to the Capybara API, and have a basic grasp of how its waiting behaviour works, you should never have to use wait_until explicitly.

Let’s make that really clear, Capybara is ridiculously good at waiting for content.

apybara could have easily figured out how to wait for this content, without you muddying up your specs with tons of explicit calls to wait_until. Our developer could simply have done this: page.find("#foo").should have_content("login failed")

Okay thank you. I'll need to do some thinking then on how to apply that to things like git config --global core.editor

const palette: { [key: string]: string } = {...

what is the TypeScript Way™ of handling the implicit any that appears due to object literals not having a standard index signature?

Even if it's const, an object can still have properties added later returning any arbitrary type. Indexing into the object would then have to return any - and that's an implicit any.

we have no way to know that the line nameMap[3] = "bob"; isn't somewhere in your program

Inflections go the other way around.In classic mode, given a missing constant Rails underscores its name and performs a file lookup. On the other hand, zeitwerk mode checks first the file system, and camelizes file names to know the constant those files are expected to define.While in common names these operations match, if acronyms or custom inflection rules are configured, they may not. For example, by default "HTMLParser".underscore is "html_parser", and "html_parser".camelize is "HtmlParser".

All these problems are solved in zeitwerk mode, it just works as expected, and require_dependency should not be used anymore, it is no longer needed.

And on any given day, developing with Svelte and its reactive nature is simply a dream to use. You can tell Svelte to track state changes on practically anything using the $: directive. And it’s quite likely that your first reactive changes will produce all the expected UI results.

The more your tests resemble the way your software is used, the more confidence they can give you.

Codica Named a Top E-commerce Web Development Company by ManifestIrina TurchanovaSaaS Growth ResearcherAwardsHomeBlogCodica WayCodica Named a Top E-commerce Web Development Company by ManifestAug 26, 202110 min readCodica is a professional team that provides software consultancy services to all-sized businesses. We have been building unique and complex custom web solutions for more than six years, helping our customers reach their business goals and prosper.

Three days before Labor Day, on Friday, September 2, 1921, the U.S. Army intervened on the side of coal companies against striking coal miners, marking the end of the Battle of Blair Mountain in southern West Virginia. The battle was the climax of two decades of low-intensity warfare across the coalfields of Appalachia, as the West Virginia miners sought to unionize and mining companies used violent tactics to undermine their efforts. The struggle turned deadly.

“Ultimately, these kind of iframe limitations are the reason why vendors should implement embeddable marketing forms with JavaScript instead of iframes….” – I couldn’t agree more. The trouble is, Pardot’s developers still believe it’s the 1990’s

Now consider we want to handle numbers in our known value set: const KNOWN_VALUES = Object.freeze(['a', 'b', 'c', 1, 2, 3]) function isKnownValue(input?: string | number) { return typeof(input) === 'string' && KNOWN_VALUES.includes(input) } Uh oh! This TypeScript compiles without errors, but it's not correct. Where as our original "naive" approach would have worked just fine. Why is that? Where is the breakdown here? It's because TypeScript's type system got in the way of the developer's initial intent. It caused us to change our code from what we intended to what it allowed. It was never the developer's intention to check that input was a string and a known value; the developer simply wanted to check whether input was a known value - but wasn't permitted to do so.

This will obviate the need for a helper function of any kind.

You particular circumstances may or may not warrant a way different from what lhunath (and other users) deem "best practices".

Remember that in the end, especially in scripting, there always are more than one way to skin a cat, but some ways are more portable, more reliable, make it simpler to handle error cases, parse the output, etc.

However, this request-by-request mindset doesn’t map well to GraphQL because there’s only one controller and the requests that come to it may be very different.

There are many projects that does not use the master branch as default. For example, Next.js uses the canary branch, the npm CLI and many more other projects uses stuff like prod, production, dev, develop, release, beta, head.

This meant that we owned both sides of the product implementation. For unit testing on the frontend, we stayed with Angular’s suggestion of Jasmine. For unit testing on the backend, we went with rspec-rails. These worked well since unit tests don’t need to cross technology boundaries.

targeting what the user actually sees

The most important guideline to give is the following: Write clean unit tests if there is actual value in testing a complex piece of logic in isolation to prevent it from breaking in the future Otherwise, try to write your specs as close to the user’s flow as possible

It’s better to test a component in the way the user interacts with it: checking the rendered template.

We want the GraphQL API to be the primary means of interacting programmatically with GitLab. To achieve this, it needs full coverage - anything possible in the REST API should also be possible in the GraphQL API.

One way to look at your current situation is that you're not paying them enough to tell you the gory details, not that you're not knowledgeable enough.

or simply install the package to devDependencies rather than dependencies, which will cause it to get bundled (and therefore compiled) with your app:

In the earlier example, I used “no-reply@” because this is, unfortunately, a common practice used by many email marketers. As a brand utilizing email, you should never expect a personal experience like email to ever be one-sided.

There's nothing to stop you from doing initializer code in a file that lives in app/models. for example class MyClass def self.run_me_when_the_class_is_loaded end end MyClass.run_me_when_the_class_is_loaded MyClass.run_me... will run when the class is loaded .... which is what we want, right? Not sure if its the Rails way.... but its extremely straightforward, and does not depend on the shifting winds of Rails.

These example are for Rails applications, but there is no dependency on Rails for using this gem. Most of the examples are applicable to any Ruby application.

The use of U+212B 'Angstrom sign', which was encoded due to round-trip mapping compatibility with an East-Asian character encoding, is discouraged, and the preferred representation is U+00C5 'capital letter A with ring above', which has the same glyph.

But in all this incongruous abundance you'll certanly find the links to expect It's just what is wanted: the tool, which is traditionally used to communicate automatically with interactive programs. And as it always occurs, there is unfortunately a little fault in it: expect needs the programming language TCL to be present. Nevertheless if it doesn't discourage you to install and learn one more, though very powerful language, then you can stop your search, because expect and TCL with or without TK have everything and even more for you to write scripts.

perl -ne 'chomp(); if (-e $_) {print "$_\n"}'

xargs -i sh -c 'test -f {} && echo {}'

“Who cares? Let’s just go with the style-guide” — to which my response is that caring about the details is in the heart of much of our doings. Yes, this is not a major issue; def self.method is not even a code smell. Actually, that whole debate is on the verge of being incidental. Yet the learning process and the gained knowledge involved in understanding each choice is alone worth the discussion. Furthermore, I believe that the class << self notation echoes a better, more stable understanding of Ruby and Object Orientation in Ruby. Lastly, remember that style-guides may change or be altered (carefully, though!).

Alternative ways to flatten a bumpy lawn

Many designers strive to create products that are so easy to navigate, their users can flow through them at first glance. To design something with this level of intuitiveness, it’s imperative designers understand affordances—what they are and how to use them.

It is also the first game I've seen whose icon for "mute" is not a crossed-out speaker/note, but a symbol for "pause" in musical notation...

Yeah, I probably think of using foam before anyone else does.

This approach is preferable to overriding authenticate_user! in your controller because it won't clobber a lot of "behind the scenes" stuff Devise does (such as storing the attempted URL so the user can be redirected after successful sign in).

Your validation functions should also treat undefined and '' as the same. This is not too difficult since both undefined and '' are falsy in javascript. So a "required" validation rule would just be error = value ? undefined : 'Required'.

Visible spectrum wrapped to join blue and green in an additive mixture of cyan

Svelte is there when I need it with useful APIs, but fades into the background as I put my app together.

This isn't really a downside to React; one of React's strengths is that it lets you control so much and slot React into your environment

Svelte is different in that by default most of your code is only going to run once; a console.log('foo') line in a component will only run when that component is first rendered.

Two of the predominant types of relationships in knowledge-representation systems are predication and the universally quantified conditional.

As to why both is_a? and kind_of? exist: I suppose it's part of Ruby's design philosophy. Python would say there should only be one way to do something; Ruby often has synonymous methods so you can use the one that sounds better. It's a matter of preference.

Small modules are extremely versatile and easy to compose together in an app with any number of other modules that suit your needs.

Even if the damned thing would be really helpful in the long run, I can't give it the time and attention needed to make it work again ...  Not right now. And ultimately never.

I'd suggest there ought to be config to disable source maps specifically, and specifically for either CSS or JS (not alwasy both), without turning off debug mode. As you note, debug mode does all sorts of different things that you might want with or without source maps.

Meh... as I said earlier, I think using Webpack is the recommended way now. Another issue is there is no way to generate source maps in production.

But yeah, I'm not sure how you would determine which was the "recommended way" really. I don't see anything in Rails docs saying either way.

But last I have seen comments from DHH, he considered webpack(er) recommended for JS, but Sprockets still the preferred solution for (S)CSS.

# This behavior can be disabled with: # # environment.unregister_postprocessor 'application/javascript', Sprockets::SafetyColons

we want source maps in production (like DHH)

I totally understand that there may be a majority still considering this a bad practice and thus keeping it disabled by default in production seem ok. But there could at least be an option to enable it for people who want to, no?

After waiting years for sprockets to support this we were very happy to see that sprockets 4 officially added support (thanks ), but then when trying to upgrade we noticed there's actually no way to use it in production... (without brittle hacks mentioned above).

An equation is meant to be solved, that is, there are some unknowns. A formula is meant to be evaluated, that is, you replace all variables in it with values and get the value of the formula.

Rails still encourages you to dump all validation errors at the top of a form, which is lulzy in this age of touchy UX

Webshim is opinionated, that a developer should always solve a problem the HTML5 way.

In production, you will never trigger one specific callback or a particular validation, only. Your application will run all code required to create a Song object, for instance. In Trailblazer, this means running the Song::Create operation, and testing that very operation with all its side-effects.

There’s no need to test controllers, models, service objects, etc. in isolation

Run the complete unit with a certain input set, and test the side-effects. This differs to the Rails Way™ testing style, where smaller units of code, such as a specific validation or a callback, are tested in complete isolation. While that might look tempting and clean, it will create a test environment that is not identical to what happens in production.

It can also be included as individual modules, i.e. Hashie::Extensions::MethodReader, Hashie::Extensions::MethodWriter and Hashie::Extensions::MethodQuery.

Instead of one big code pile, activities will gently enforce a clean, standardized way for organizing code.

the Activity component is the heart of TRB

Patching has no implicit, magical side-effects and is strongly encouraged to customize flows for a specific case in a quick and consise way.

It's recommended to configure this library by setting environment variables.

Have you ever felt like a framework was getting in the way instead of helping you go faster? Maybe you’re stuck on some simple task that would be easy to do manually, but your framework is making you jump through configuration hoops. I end up getting lost in a sea of documentation (or no documentation), and the search for that one magical config key takes just a tad bit too long. It’s a productivity sink, and worse than the time delay it adds to my frustration throughout the day.

I'm not a fan of listing exceptions functions can throw, especially here in Python, where it's easier to ask forgiveness than permission.

And they are not the only way to handle errors.

And a word of warning. If you haven’t come across things like monads before, they might seem really… different. Working with tools like these takes a mind shift. And that can be hard work to start with.

In other words: the controllers usually contain only routing and rendering code and dispatch instantly to a particular operation/activity class.

Feel free to pick and choose what you need for your applications.

Instead of dealing with a mix of before_filters, Rack-middlewares, controller code and callbacks, an endpoint is just another activity and allows to be customized with the well-established Trailblazer mechanics.