5,744 Matching Annotations
  1. Mar 2021
    1. according to Hao, Mark Zuckerberg wants to increase the number of people who log into Facebook six days a week. I’m not going to get into whether this is good or bad here, but it certainly shows that what you are doing, and how you are doing it, is very important to Facebook.

      Can we leverage these data points to follow a movement like Meatless Monday to encourage people to not use Facebook two days a week to cause this data analysis to crash?

      Anything that is measured can be gamed. But there's also the issue of a moving target because Facebook will change it's target which then means the community activism will need to change it's target as well. (This may be fine if the point is community engagement and education as the overall mission, in which case the changing target continually engages people and brings in new people to consider what is happening and why.)

    1. Muse

      Reminded of Chapter 11 in The Odyssey:

      I am likely going to retire this year and I find resonance in this as it appears that I will be accepting a "voluntary" buyout at the end of this fiscal year. My long sea journey, 25 years worth in teaching, will be officially over. Hence...the appeal to propitiate the gods, to let all the pain go, to ask forgiveness of the implacable Poseidon.

    1. Franklin thereby invented the first newspaper chain. It was more than a business venture, for like many publishers since he believed that the press had a public-service duty

      Long before the internet, and even national level newspapers, Franklin understood the power of the written word. His, and other like minded individual’s words were distributed in the form of pamphlets, that extolled their ideas on liberty and justice, and spread those words to all who were interested.

    1. Third configurable block to run.

      I like how they identify in the description which order things run in: 1st, 2nd, 3rd, and last.

      Though, it would be more readable to have a list of them, in chronological order, rather than having them listed in alphabetical order.

    2. Last configurable block to run. Called after frameworks initialize.
    1. he goes on to talk about third party problems and how you're never guaranteed something is written correctly or that even if it is you don't know if it's the most optimal solution
    2. Write modules for publication, even if you only use them privately. You will appreciate documentation in the future.
    3. Second, I don't agree that there are too many small modules. In fact, I wish every common function existed as its own module. Even the maintainers of utility libraries like Underscore and Lodash have realized the benefits of modularity and allowed you to install individual utilities from their library as separate modules. From where I sit that seems like a smart move. Why should I import the entirety of Underscore just to use one function? Instead I'd rather see more "function suites" where a bunch of utilities are all published separately but under a namespace or some kind of common name prefix to make them easier to find. The way Underscore and Lodash have approached this issue is perfect. It gives consumers of their packages options and flexibility while still letting people like Dave import the whole entire library if that's what they really want to do.
    1. non-regression testing

      That would probably be a better name because you're actually testing/verifying that there hasn't been any regression.

      You're testing for the absence of regression. But I guess testing for one also tests for the other, so it probably doesn't matter. (If something is not true you know it is false, etc.)

    1. here is my set of best practices.I review libraries before adding them to my project. This involves skimming the code or reading it in its entirety if short, skimming the list of its dependencies, and making some quality judgements on liveliness, reliability, and maintainability in case I need to fix things myself. Note that length isn't a factor on its own, but may figure into some of these other estimates. I have on occasion pasted short modules directly into my code because I didn't think their recursive dependencies were justified.I then pin the library version and all of its dependencies with npm-shrinkwrap.Periodically, or when I need specific changes, I use npm-check to review updates. Here, I actually do look at all the changes since my pinned version, through a combination of change and commit logs. I make the call on whether the fixes and improvements outweigh the risk of updating; usually the changes are trivial and the answer is yes, so I update, shrinkwrap, skim the diff, done.I prefer not to pull in dependencies at deploy time, since I don't need the headache of github or npm being down when I need to deploy, and production machines may not have external internet access, let alone toolchains for compiling binary modules. Npm-pack followed by npm-install of the tarball is your friend here, and gets you pretty close to 100% reproducible deploys and rollbacks.This list intentionally has lots of judgement calls and few absolute rules. I don't follow all of them for all of my projects, but it is what I would consider a reasonable process for things that matter.
    2. That said, I wish more people would talk both sides. Yes, every dependency has a cost. BUT the alternatives aren't cost free either. For all the ranting against micropackages, I'm not seeing a good pro/con discussion.
    1. Whenever majorities trample upon the rights of minorities—when men are denied even the privilege of having their causes of complaint examined into—when measures, which they deem for their relief, are rejected by the despotism of a silent majority at a second reading—when such become the rules of our legislation, the Congress of this Union will no longer justly represent a republican people.
    1. JavaScript needs to fly from its comfy nest, and learn to survive on its own, on equal terms with other languages and run-times. It’s time to grow up, kid.
    2. If JavaScript were detached from the client and server platforms, the pressure of being a monoculture would be lifted — the next iteration of the JavaScript language or run-time would no longer have to please every developer in the world, but instead could focus on pleasing a much smaller audience of developers who love JavaScript and thrive with it, while enabling others to move to alternative languages or run-times.
    3. We standardize on a finite subset of JS (such as asm.js) — and avoid the endless struggle through future iterations of the JavaScript language, competing super-sets and transpilers

      asm.js and RPython sound similar (restrictive subsets)

    1. much software requires continuous changes to meet new requirements and correct bugs, and re-engineering software each time a change is made is rarely practical.
    1. Normally you should not register a named module, but instead register as an anonymous module: define(function () {}); This allows users of your code to rename your library to a name suitable for their project layout. It also allows them to map your module to a dependency name that is used by other libraries.
    1. I don't understand why this isn't being considered a bigger deal by maintainrs/the community. Don't most Rails developers use SCSS? It's included by default in a new Rails app. Along with sprockets 4. I am mystified how anyone is managing to debug CSS in Rails at all these days, that this issue is being ignored makes sprockets seem like abandonware to me, or makes me wonder if nobody else is using sprockets 4, or what!
    2. I don't myself understand what's going on, it clearly has something to do with source maps, but may also have to do with other sprockets changes.
    3. I don't really understand what's going on. Clearly source maps have something to do with it -- a source map feature that doesn't handle SCSS very well, apparently.
    4. Is there a PR to... something? sassc-rails? That would make the patch not necessary? (I don't know if there's any good way to monkey-patch that in, I think you have to fork? So some change seems required...) Should the defaults be different somehow? This is very difficult to figure out.
    5. I'm not sure about all consequences of my change and this is very complex.
    1. we want source maps in production (like DHH)
    2. 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?
    3. 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).
    4. The only place I can find it is in the sprockets-rails gem. javascript_include_tag calls this: def find_debug_asset(path) if asset = find_asset(path, pipeline: :debug) raise_unless_precompiled_asset asset.logical_path.sub('.debug', '') asset end end
    5. It seems I'm in the minority, and Sprockets seems to already pretty far along in the beta process, so at most we should add a configuration option to enable it for static compilation.
    1. I'm kinda stuck at the moment, going around in circles. Everything is really heavily coupled. I would like to get to the point where no load is called from within processors, but i'm not sure if that's possible. Currently the API and the caching strategies are fighting me at every step of the way. I have a branch where i'm hacking through some refactoring, no light at the end of the tunnel yet though :(
    2. If a company really wanted to invest, I would prefer they dedicated an employee for X hours a week for Y months than money.
    3. Money could be good if it is spent to provide some of the above things. Money on it's own is hard because then it means I would have to spend time book-keeping and managing instead of programming.
    1. it's super hard to test master because i have no idea which gems need to be updated. is there a guide on how to take a rails 4.2 project to master sprockets without everything mysteriously exploding? ill try to make a repro case but its hard to tell where to even start
    1. Fits the ideal behind HTML HTML stands for "HyperText Markup Language"; its purpose is to mark up, or label, your content. The more accurately you mark it up, the better. New elements are being introduced in HTML5 to more accurately label common web page parts, such as headers and footers.
  2. jangawolof.org jangawolof.org
    1. Degg naa ko muy tari Alxuraan.

      Je l'ai entendu réciter des versets du Coran.

      degg v. -- hear.

      naa -- I already/definitely.

      ko -- him, her, it.

      muy -- from -- he, she, it (?).

      tari -- recitation.

      alxuraan ji -- (Arabic: al-Qurʼān) the Koran.

    2. Beykat yi duñu dem tool altine.

      Les cultivateurs ne vont pas au champ le lundi.

      beykat bi -- farmer 👩🏾‍🌾 (from bey -- to farm/cultivate).

      yi -- the (indicates plurality).

      duñu -- do not/no one (?).

      dem v. -- to go, leave, etc.

      tool bi -- field, orchard.

      altine ji -- (Arabic) Monday.

    3. Fibar bi jàngal na taawan bu góor ni ñuy dagge reeni aloom.

      Le guérisseur a appris à son fils aîné comment on coupe les racines du Diospyros.

      fibar -- (fibar bi? the healer? as in feebar / fièvre / fever? -- used as a general term for sickness).

      bi -- the (indicates nearness).

      jàngal v. -- to teach (something to someone), to learn (something from someone) -- compare with jàng (as in janga wolof) and jàngale.

      na -- pr. circ. way, defined, distant. How? 'Or' What. function indicator. As.

      taaw+an (taaw) bi -- first child, eldest. (taawan -- his eldest).

      bu -- the (indicates relativeness).

      góor gi -- man; male.

      ni -- pr. circ. way, defined, distant. How? 'Or' What. function indicator. As.

      ñuy -- they (?).

      dagg+e (dagg) v. -- cut; to cut.

      reen+i (reen) bi -- root, taproot, support.

      aloom gi -- Diospyros mespiliformis, EBENACEA (tree).

      https://www.youtube.com/watch?v=BryN2nVE3jY

    4. Dafa ànd ak moroom yi àll ba, fori aloom.

      Il est allé dans la brousse ramasser des fruits de Diospyros avec ses camarades.

      dafa -- he/she.

      ànd v. / ànd bi -- to be together, to go together; copulate; going together, fellowship; placenta.

      ak -- and, with, etc.

      moroom mi -- comrade of the same age group, equal, companion, neighbor.

      yi -- the (plural).

      àll bi -- large expanse of uninhabited land, bush; distant, as opposed to home.

      ba -- the (indicates distance).

      for+i (for) v. -- to pick up.

      aloom bi -- edible fruit of Diospyros mespiliformis (aloom gi for the tree).

      https://www.youtube.com/watch?v=nL4iHgp5ejk

    5. Almet ji dafa tooy.

      Les allumettes sont mouillées.

      almet ji -- (French) matches.

      ji -- the (indicates nearness).

      dafa -- are (?).

      tooy v. -- to be/get wet, humid, to be soaked; be fresh, be green.

      https://www.youtube.com/watch?v=fQWvy_lYlv0

    6. Fexeel ba kër gi bañ ñàkk alkol.

      Veille à ce qu'il ne manque pas d'alcool à la maison.

      fexe+el (fexe) v. -- search/seek by all means.

      ba -- the (?).

      kër gi -- house; family.

      gi -- the (indicates nearness).

      bañ v. -- refuse, resist, refuse to; to hate; verb marking the negation in subordinate clauses.

      ñàkk v. / ñàkk bi -- vaccinate / vaccine (not sure exactly how this fits in the sentence if it's even the right translation -- perhaps it has to do with surgical alcohol rather than drinking alcohol).

      alkol ji -- (French) surgical alcohol. (I'm certain this is also used for the type of alcohol you drink -- but sangara is probably the most used term).

      https://www.youtube.com/watch?v=SsUjvAItysA

    7. Alkaati ba jàpp na sàcc.

      Le gardien de la paix a pris un voleur.

      alkaati bi -- policeman.

      ba -- the (indicates remoteness).

      jàpp v. -- grab, take, stop.

      na -- (?).

      sàcc bi -- thief.

      https://www.youtube.com/watch?v=b9gOjBhk1q0

    8. Noo mën a def dinga fey alamaan bi.

      Quoi que tu fasses, tu paieras l'amende.

      noo -- you (?)

      mën v. -- power ; be stronger than 💪🏽; can, will.

      a -- (?).

      def v. -- do, commit, execute; to put.

      dinga -- you will.

      fey v. -- turn off, switch off 📴, appease; pay 💵.

      alamaan bi -- (French: l'amende) fine.

      bi -- the.

      https://www.youtube.com/watch?v=4y6PTqs1uCc

    9. Sér bi aju na ci caru garab gi.

      Le pagne s'est accroché à la branche.

      sér bi -- loincloth. 🩲

      bi -- the.

      aju v. -- hang on.

      na -- (?).

      ci -- close; at @, in, on, inside, to.

      car+u (car) bi -- twig, branch. 🎋

      garab gi -- tree 🌲, plant 🪴; medicine 💊, remedy.

      gi -- the.

      https://www.youtube.com/watch?v=3WS1Q1LT1ks&t=36s

    10. Faatu aj na laytanam.

      Faatu a placé sa calebasse en haut.

      faatu -- a feminine name of Arabic origin. 👩🏽

      aj v. -- place on top 🔝, perch.

      na -- her (?).

      laytan+am (laytan) gi -- small calabash (to have).

    11. Sama nijaay aj na ñaari yoon.

      Mon oncle a effectué deux fois le pèlerinage à La Mecque.

      sama -- my.

      nijaay ji n. -- maternal uncle; term of reference and address to designate the husband, in conservative circles.

      aj (Arabic) v. -- make the pilgrimage to Mecca. 🕋; deceased ☠️ (for a religious personality).

      na -- he (?).

      ñaar+i (ñaar) -- twice; two. 2️⃣

      yoon wi n. -- lane, path, track 🛤; law, regulation, legislation; times.

    12. Xabaar bi agsi na démb.

      La nouvelle est arrivée hier.

      xabaar (Arabic) v. -- report (a new one).

      bi -- the.

      agsi v. -- to arrive, to arise.

      na -- as (?).

      démb ji -- the past; yesterday 📆, long ago.

    1. 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.
    2. There’s no need to test controllers, models, service objects, etc. in isolation
    3. 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.
    1. This is the story of how a bill to save the vote and preserve a semblance of democracy for millions of Americans died at the hands of an intransigent, reactionary minority in the Senate, which used the filibuster to do its dirty work

      The author starts off by personifying "the bill" as something that was supposed to save millions of Americans, but rather was killed by Senators. He immediately provides a brief overview of the claim of his essay before developing his narrative. This way, the audience gets a glimpse of the issue that the author will tackle. Also, by using words such as "intransigent and reactionary", the audience already understands that the author is going to be criticizing the senators for their action.

    1. Admittedly, both the signature and the return values of invoke feel a bit clumsy. That’s becaus we’re currently working with the low-level interfaces.
    2. Instead of one big code pile, activities will gently enforce a clean, standardized way for organizing code.
    3. the Activity component is the heart of TRB
    4. So why the over-complication? What we got now is replicating a chain of && in the former version. This time, however, you will know which condition failed and what went in by using tracing. Look at the trace above - it’s impossible to not understand what was going on.
    5. Hey, that’s is an imaginary complication of our example - please don’t do this with every condition you have in your app.
  3. Feb 2021
    1. For branching out a separate path in an activity, use the Path() macro. It’s a convenient, simple way to declare alternative routes

      Seems like this would be a very common need: once you switch to a custom failure track, you want it to stay on that track until the end!!!

      The problem is that in a Railway, everything automatically has 2 outputs. But we really only need one (which is exactly what Path gives us). And you end up fighting the defaults when there are the automatic 2 outputs, because you have to remember to explicitly/verbosely redirect all of those outputs or they may end up going somewhere you don't want them to go.

      The default behavior of everything going to the next defined step is not helpful for doing that, and in fact is quite frustrating because you don't want unrelated steps to accidentally end up on one of the tasks in your custom failure track.

      And you can't use fail for custom-track steps becase that breaks magnetic_to for some reason.

      I was finding myself very in need of something like this, and was about to write my own DSL, but then I discovered this. I still think it needs a better DSL than this, but at least they provided a way to do this. Much needed.

      For this example, I might write something like this:

      step :decide_type, Output(Activity::Left, :credit_card) => Track(:with_credit_card)
      
      # Create the track, which would automatically create an implicit End with the same id.
      Track(:with_credit_card) do
          step :authorize
          step :charge
      end
      

      I guess that's not much different than theirs. Main improvement is it avoids ugly need to specify end_id/end_task.

      But that wouldn't actually be enough either in this example, because you would actually want to have a failure track there and a path doesn't have one ... so it sounds like Subprocess and a new self-contained ProcessCreditCard Railway would be the best solution for this particular example... Subprocess is the ultimate in flexibility and gives us all the flexibility we need)


      But what if you had a path that you needed to direct to from 2 different tasks' outputs?

      Example: I came up with this, but it takes a lot of effort to keep my custom path/track hidden/"isolated" and prevent other tasks from automatically/implicitly going into those steps:

      class Example::ValidationErrorTrack < Trailblazer::Activity::Railway
        step :validate_model, Output(:failure) => Track(:validation_error)
        step :save,           Output(:failure) => Track(:validation_error)
      
        # Can't use fail here or the magnetic_to won't work and  Track(:validation_error) won't work
        step :log_validation_error, magnetic_to: :validation_error,
          Output(:success) => End(:validation_error), 
          Output(:failure) => End(:validation_error) 
      end
      
      puts Trailblazer::Developer.render o
      Reloading...
      
      #<Start/:default>
       {Trailblazer::Activity::Right} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=validate_model>
      #<Trailblazer::Activity::TaskBuilder::Task user_proc=validate_model>
       {Trailblazer::Activity::Left} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=log_validation_error>
       {Trailblazer::Activity::Right} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=save>
      #<Trailblazer::Activity::TaskBuilder::Task user_proc=save>
       {Trailblazer::Activity::Left} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=log_validation_error>
       {Trailblazer::Activity::Right} => #<End/:success>
      #<Trailblazer::Activity::TaskBuilder::Task user_proc=log_validation_error>
       {Trailblazer::Activity::Left} => #<End/:validation_error>
       {Trailblazer::Activity::Right} => #<End/:validation_error>
      #<End/:success>
      
      #<End/:validation_error>
      
      #<End/:failure>
      

      Now attempt to do it with Path... Does the Path() have an ID we can reference? Or maybe we just keep a reference to the object and use it directly in 2 different places?

      class Example::ValidationErrorTrack::VPathHelper1 < Trailblazer::Activity::Railway
         validation_error_path = Path(end_id: "End.validation_error", end_task: End(:validation_error)) do
          step :log_validation_error
        end
        step :validate_model, Output(:failure) => validation_error_path
        step :save,           Output(:failure) => validation_error_path
      end
      
      o=Example::ValidationErrorTrack::VPathHelper1; puts Trailblazer::Developer.render o
      Reloading...
      
      #<Start/:default>
       {Trailblazer::Activity::Right} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=validate_model>
      #<Trailblazer::Activity::TaskBuilder::Task user_proc=validate_model>
       {Trailblazer::Activity::Left} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=log_validation_error>
       {Trailblazer::Activity::Right} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=save>
      #<Trailblazer::Activity::TaskBuilder::Task user_proc=log_validation_error>
       {Trailblazer::Activity::Right} => #<End/:validation_error>
      #<Trailblazer::Activity::TaskBuilder::Task user_proc=save>
       {Trailblazer::Activity::Left} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=log_validation_error>
       {Trailblazer::Activity::Right} => #<End/:success>
      #<End/:success>
      
      #<End/:validation_error>
      
      #<End/:failure>
      

      It's just too bad that:

      • there's not a Railway helper in case you want multiple outputs, though we could probably create one pretty easily using Path as our template
      • we can't "inline" a separate Railway acitivity (Subprocess "nests" it rather than "inlines")
    2. step :direct_debit

      I don't think we would/should really want to make this the "success" (Right) path and :credit_card be the "failure" (Left) track.

      Maybe it's okay to repurpose Left and Right for something other than failure/success ... but only if we can actually change the default semantic of those signals/outputs. Is that possible? Maybe there's a way to override or delete the default outputs?

    1. Personally, I'm starting to think that the feature where it automatically adds xray.js to the document is more trouble than it's worth. I propose that we remove that automatic feature and just make it part of the install instructions that you need to add this line to your template/layout: <%= javascript_include_tag 'xray', nonce: true if Rails.env.development? %>
    1. now that I realize how easy it is to just manually include this in my app: <%= javascript_include_tag 'xray', nonce: true if Rails.env.development? %> I regret even wasting my time getting it to automatically look for and add a nonce to the auto-injected xray.js script
    2. This is failing CI because CI is testing against Rails < 6. I think the appropriate next steps are: Open a separate PR to add Rails 6 to the CI matrix Update this PR to only run CSP-related test code for Rails >= 6.0.0 Can you help with either or both of those?
    1. At work, we often mention "throwing something over the fence" and "wrong rock" so there is (to us) a proverbial fence and a proverbial wrong rock.
    1. Keeping bootstrap-sass in sync with upstream changes from Bootstrap used to be an error prone and time consuming manual process. With Bootstrap 3 we have introduced a converter that automates this.
    1. For example, what if your site has a customer interface and an “admin” interface? If the two have totally different designs and features, then it might be considerable overhead to ship the entirety of the admin interface to every customer on the regular site.
    2. Before we get into what the manifest.js does, let’s look at what it is replacing.
    3. 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.
    1. Did the district just not see the problem with taking away some schools busing?

    2. why don't the teachers look at this and see that the cause is racism?

    3. I find it crazy that the school lost 100 students weekly.

    4. I think it is ridiculous that they came up with the idea to segregate the schools, while also leaving black students with the worst school supplies.

    5. I thought that these numbers where really interesting, especially when the Hispanic enrollments increased

    6. Its cool that different nationality and race are on the city council board

    1. found that using only the Pascal-provided control structures, the correct solution was given by only 20% of the subjects, while no subject wrote incorrect code for this problem if allowed to write a return from the middle of a loop.
    1. Let’s start with the same number dividing example, which returns 0 when the error happens. Maybe instead we can indicate that the result was not successful without any explicit numerical value?
    2. You can use container values, that wraps actual success or error value into a thin wrapper with utility methods to work with this value. That’s exactly why we have created @dry-python/returns project. So you can make your functions return something meaningful, typed, and safe.
    3. Not all cases can be covered and easily restored. And sometimes when we will reuse this function for different use-cases we will find out that it requires different restore logic.
    4. You still need to have a solid experience to spot these potential problems in a perfectly readable and typed code.
    5. So, the sad conclusion is: all problems must be resolved individually depending on a specific usage context. There’s no silver bullet to resolve all ZeroDivisionErrors once and for all. And again, I am not even covering complex IO flows with retry policies and expotential timeouts.
    1. it is inconvenient to write specific implementations for each datatype contained, especially if the code for each datatype is virtually identical. For example, in C++, this duplication of code can be circumvented by defining a class template
    1. Endpoint is the missing link between your routing (Rails, Hanami, …) and the “operation” to be called. It provides standard behavior for all cases 404, 401, 403, etc and lets you hook in your own logic like Devise or Tyrant authentication, again, using TRB activity mechanics.
    2. What this means is: I better refrain from writing a new book and we rather focus on more and better docs.

      I'm glad. I didn't like that the book (which is essentially a form of documentation/tutorial) was proprietary.

      I think it's better to make documentation and tutorials be community-driven free content

    3. Using a terminus to indicate a certain outcome - in turn - allows for much stronger interfaces across nested activities and less guessing! For example, in the new endpoint gem, the not_found terminus is then wired to a special “404 track” that handles the case of “model not found”. The beautiful thing here is: there is no guessing by inspecting ctx[:model] or the like - the not_found end has only one meaning!
    4. A major improvement here is the ability to maintain more than two explicit termini. In 2.0, you had the success and the failure termini (or “ends” as we used to call them). Now, additional ends such as not_found can be leveraged to communicate a non-binary outcome of your activity or operation.
    5. The new 2.1 version comes with a few necessary but reasonable changes in method signatures. As painful as that might sound to your Rails-spoiled ears, we preferred to fix design mistakes now before dragging them on forever.
    6. To make it short: we returned to the Rails Way™, lowering our heads in shame, and adhere to the Rails file and class naming structure for operations.
    7. It’s so simple that I sometimes wonder why it took years to develop it!
    8. There is nothing wrong with building your own “service layer”, and many companies have left the Traiblazer track in the past years due to problems they had and that we think we now fixed.
    1. In Trailblazer, models are completely empty. They solely contain associations and finders. No business logic is allowed in models.
    2. While Trailblazer offers you abstraction layers for all aspects of Ruby On Rails, it does not missionize you. Wherever you want, you may fall back to the "Rails Way" with fat models, monolithic controllers, global helpers, etc. This is not a bad thing, but allows you to step-wise introduce Trailblazer's encapsulation in your app without having to rewrite it.
    1. bird counts across the United States have fallen a staggering 29 percent in the last 50 years

      29% in 50 years? That means in the next 50 years half of the bird population could decrease!

    1. Also, this code will fail if $$ is not the process group leader, such as when the script is run under strace. Since a call to setsid(2) is probably tricky from a shell script, one approach might be to ps and obtain the process group ID from that.
    2. you really need #!/bin/sh -m for correct behavior of nested subshells. fg, bg, and wait wont work correctly otherwise
    1. The Quest for Truth

      The quest for Truth is everywhere and not limited to the economic topics linked here. This is just a topic that started a thought process where I had access to a convenient tool (Hypothesis) to bookmark my thoughts and research.

      Primary thought is: The Quest for Truth. Subcategories would provide a structured topic for the thought. In this case the subcategory would be: US Economy, Inflation

      The TRUTH is a concept comprised of inconsistencies and targets that frequently move.

      Targets (data, methods, people, time, semantics, agenda, demographic, motive, means, media, money, status) hold a position in time long enough to fulfill a purpose or agenda. Sometimes they don't consciously change, but history over time shines light and opens cracks in original narrative that leads to new truth's, real or imagined.

      Verifying and validating certain Truth is very difficult. Why is That?
    1. A popular strategy for bootstrapping networks is what I like to call “come for the tool, stay for the network.” The idea is to initially attract users with a single-player tool and then, over time, get them to participate in a network. The tool helps get to initial critical mass. The network creates the long term value for users, and defensibility for the company.

      This is an interesting and useful strategy. I've heard the idea several times before.

      I'm curious if this is the oldest version of it? I have to imagine that there are earlier versions of it dating back to 2011 or 2012 if not earlier.

    1. No one has requested it before so it's certainly not something we're planning to add.
    2. To give a little more context, structures like this often come up in my work when dealing with NoSQL datastores, especially ones that rely heavily on JSON, like Firebase, where a records unique ID isn't part of the record itself, just a key that points to it. I think most Ruby/Rails projects tend towards use cases where these sort of datastores aren't appropriate/necessary, so it makes sense that this wouldn't come up as quickly as other structures.
    1. Learn more about how we made the decision to put our guidance in the public domain
    2. In order to support easy reuse, revision, remixing, and redistribution, the entire Hypothesis Help knowledge base by Hypothesis is dedicated to the public domain via CC CC0 1.0. While we appreciate attribution and links back to Hypothesis from anywhere these works are published, they are not required.
    1. But ActiveModel doesn't support out of the box argument parsing, e.g. having a datetime attribute be a datetime attribute and a boolean attribute be a boolean attribute.

      Doesn't it now, with the (newer) ActiveModel::Attributes API?

    1. Examples of different ways of defining forms

      Wow, that's a lot of different ways.

      The inline_form way in particular seems interesting to me, though it's worth noting that that method is just an example, not actually part of this project's code, so it's not really a first-class option like the other options.

    1. The press release also quoted a UA assistant provost for institutional research who explained that while the swipes of student ID cards were not used in the current student retention analytics, about 800 other data points were

      The research in questions was not currently being used by the institution to improve rention, but other student data was already being used for that purpose

    2. The researcher noted that the data she had used had been anonymized before she was given access to it—however, she added that if/when her research might inform the ongoing efforts to improve student retention, the student’s personal details would be “shared” with the students' academic advisers.

      The data was anonymized before she was given access, but she admitted that there might be interest in sharing students' personal details with academic advisors

    3. She then used that data to create large networks mapping which students interacted with one another and how often.

      The researcher sought to track the personal interactions of students with one another

    4. On the university’s website, a press release

      The university share the finding of the research after the fact

    5. At the University of Arizona, for example, a researcher analyzed the swipes of student ID cards at locations across campus, “to see what they reveal about students' routines and relationships, and what that means for their likelihood of returning to campus after their freshman year.”

      Fact. Student ID Cards Collect Data Fact. A researcher was given access to this data for her own purposes.

    1. If you don't understand both sides of an issue, you cannot make an intelligent choice; in fact, if you don't understand all the ramifications of your actions, you're not designing at all. You're stumbling in the dark.
    2. Stating that some language feature or common programming idiom (like accessors) has problems is not the same thing as saying you should never use them under any circumstances.
    3. By the same token, marketing or political incentives often push design idioms
    1. with ActiveForm-Rails, validations is the responsability of the form and not of the models. There is no need to synchronize errors from the form to the models and vice versa.

      But if you intend to save to a model after the form validates, then you can't escape the models' validations:

      either you check that the models pass their own validations ahead of time (like I want to do, and I think @mattheworiordan was wanting to do), or you have to accept that one of the following outcomes is possible/inevitable if the models' own validations fail:

      1. if you use object.save then it may silently fail to save
      2. if you use object.save then it will fail to save and raise an error

      Are either of those outcomes acceptable to you? To me, they seem not to be. Hence we must also check for / handle the models' validations. Hence we need a way to aggregate errors from both the form object (context-specific validations) and from the models (unconditional/invariant validations that should always be checked by the model), and present them to the user.

      What do you guys find to be the best way to accomplish that?

      I am interested to know what best practices you use / still use today after all these years. I keep finding myself running into this same problem/need, which is how I ended up looking for what the current options are for form objects today...

    2. DSLs can be problematic for the user since the user has to manage state (e.g. am I supposed to call valid? first or update_attributes?). This is exactly why the #validate is the only method to change state in Reform.
    3. The reason Reform does updating attributes and validation in the same step is because I wanna reduce public methods. This is to save users from having to remember state.

      I see what he means, but what would you call this (tag)? "have to remember state"? maybe "have to remember" is close enough

      Or maybe order is important / do things in the right order is all we need to describe the problem/need.

    1. These two mistakes, especially the second one, plant worries in your customers mind before they’ve even had time to think of them.
    2. Stop warning people – no contract, no obligations, cancel anytime – companies can’t resist saying this on every pricing page but by using negative words they’re just putting ideas into people’s heads.
    1. Let's face it, these days, if you want to socialize, you don't go out to the mall or the library, and it's a 50/50 shot if you even have anything resembling a town square. You go on the internet.

      And this is the problematic part of the internet as a town square: we have no defined governance or pale beyond which to cast people who go far beyond societal norms.

    1. The Timeless Way of Building is the first in a series of books which describe an entirely new attitude to architec- ture and planning. The books are intended to provide a complete working alternative to our present ideas about ar- chitecture, building, and planning—~an alternative which will, we hope, gradually replace current ideas and practices,

      [[the timeless way of building]]