326 Matching Annotations
  1. Last 7 days
    1. The paradox of hoarding isthat no matter how much we collect and accumulate, it’s neverenough.

      How is the paradox of hoarding related to the collector's fallacy?

      Regardless of how much you collect, you can't take it with you. So what's the value? - Having and using it to sustain you while you're alive. - Combining it in creative ways to leave behind new ideas and new innovations for those who follow you. - others?

  2. Jun 2022
    1. A patent is defined as a right granted to an individual or company to protect their invention. It is also known as government-granted exclusive rights over a product or idea. Once your idea is patented no one copies, steals or sells it. Patents give you full control over your product or idea as it comes under the law now.
  3. Apr 2022
  4. Mar 2022
    1. The last note is that when binding commands to keyboard shortcuts it is often necessary to only have one command, not two commands connected with a pipe like we use above. You can accomplish this by invoking your piped command as a command string argumetn to a new shell like this:
    1. I mean there’s no single answer that will solve all of our future problems. There’s no magic bullet. Instead there are thousands of answers — at least. You can be one of them if you choose to be.'
    1. Ruby Object Mapper (rom-rb) is a fast ruby persistence library with the goal of providing powerful object mapping capabilities without limiting the full power of the underlying datastore.
  5. Feb 2022
    1. In the early chapters Ahrens outlines the general form and method for taking notes for a zettelkasten, though he's not overly descriptive of the method and provides no direct examples.

      In the middle chapters he talks broadly about learning research and how the zettelkasten method dovetails with these methods.

      He does this almost as if he's a good teacher showing the student an outline of what to do and why, but leaving it up to them to actually do the work and experimentation to come up with their own specific methods of use to best suit their purposes. This allows them to do the work themselves so that they have a better chance of following a simple, but easy set of rules, but in a way that will allow them to potentially more quickly become an expert at the practice.

      “The one who does the work does the learning,” writes Doyle (2008, 63) [Section 10.5]

      In some sense, he's actively practicing what he preaches as a teaching device within his own book!

      I think that this point may be actively missed by those readers who aren't actively engaging with and converting his ideas into their own and doing the work which he's actively suggesting.

    1. Employing theLinked Data paradigm for enterprise data integration has anumber of advantages:
      1. Identifizierung mit URI/IRIs

      Unternehmen, Konzepte, Daten und Metadaten können über Abteilungen, Abteilungen, Niederlassungen, Tochtergesellschaften.

      1. Zugang - dereferenzierbar URI/IRIs bieten einen einheitlichen Datenzugriffsmechanismus.

      2. Integration

      3. Das triple-basierte RDF-Datenmodell erleichtert die Integration und das Mapping zwischen verschiedenen anderen Datenmodellen (z.B. XML, RDB, JSON). Kohärenz - Schema, Daten und Metadaten können über System- und Organisationsgrenzen hinweg nahtlos miteinander verknüpft werden Grenzen.

      4. Provenienz

      5. ist gewährleistet, da der Ursprung der Informationen Herkunft der Informationen in den Bezeichnern kodiert ist. Governance - Identifikatoren, Metadaten und Schema können inkrementell und dezentral verwaltet und dezentralisiert verwaltet werden.

      6. Agilität

      7. Vokabulare, Vokabularelemente Vokabulare, Vokabularelemente und Datenquellen können schrittweise und nach dem Prinzip "pay-as-you-go" hinzugefügt werden.
  6. Jan 2022
    1. Point being (again), definitions seem to differ, and what you call "full stack" is what I call "batteries-included framework". Full stack simply means (for me) that it gives you a way of building frontend and backend code, but implies nothing about what functionality is included in either part.
    1. This is just one of those things in CSS that seems easy to understand (and really, it should be), but it’s sometimes not — because of the way that percentages work in CSS.
    1. The Google Career Certificates Employer Consortium consists of over 150 U.S. companies like Deloitte, Infosys, Snap Inc., Target, Verizon, and of course, Google. These companies span multiple sectors and are committed to considering Google Career Certificate graduates for entry-level jobs. Upon completion of a Google Career Certificate, you will gain access to an exclusive job platform where you can easily apply to opportunities from employers with open jobs. https://grow.google/certificates/it-support/#?modal_active=none

      The consortium consists of 150 companies in December, 2021. This will increase. Significant community college reaction is (wisely?) sensing an opportunity instead of a threat. They are collaborating and indications are they will benefit across multiple verticals. I'm excited to see how this plays out in 4-year spaces of Higher Ed:

      • Will HE react to a threat or an opportunity?
      • How might domains like interpersonal and intercultural skills be credentialed in a way that fosters an interoperable ecosystem between HE and industry efforts like this?
      • How will HE endeavor to consume credentials issued by non-accredited bodies?
  7. Nov 2021
  8. Oct 2021
    1. From a client side/application (as a whole) standpoint this is an internal endpoint, for the router of SvelteKit this would be an external resource.
    1. DIRECTORY (in progress): This post is my directory. This post will be tagged with all tags I ever use (in chronological order). It allows people to see all my tags, not just the top 50. Additionally, this allows me to keep track. I plan on sorting tags in categories in reply to this comment.

      External links:

      Tags categories will be posted in comments of this post.

  9. Sep 2021
  10. Aug 2021
    1. Caution: This is NOT the current local time in most locations in that time zone North America: Only some locations are currently on MST because most places in this time zone are currently on summer time / daylight saving time and are observing MDT.
    2. In everyday usage, MST is often referred to as Mountain Time (MT) or the Mountain Time Zone. This can add a bit of confusion as the term Mountain Time does not differentiate between standard time and Daylight Saving Time, so Mountain Time switches between MST and MDT in areas that use DST during part of the year.
    1. Pipe assessment is never an elective activity. It's usually forced upon you when the toilets refuse to flush and wastewater comes up instead of going down.
  11. Jul 2021
  12. datatracker.ietf.org datatracker.ietf.org
    1. The goal of this technology is to provide a mechanism for browser-based applications that need two-way communication with servers that does not rely on opening multiple HTTP connections (e.g., using XMLHttpRequest or <iframe>s and long polling).
    1. It’s fun but when would we ever use things like this in actual code?When it’s well tested, commented, documented, and becomes an understood idiom of your code base.We focus so much on black magic and avoiding it that we rarely have a chance to enjoy any of the benefits. When used responsibly and when necessary, it gives a lot of power and expressiveness.
  13. Jun 2021
  14. May 2021
    1. First of all, I would start off presenting yourself: Dear XYZ support team I am the web developer in charge of example.com website. By presenting you this way, you are establishing the frame to treat you, hinting that you should be presupposed to be somewhat proficient, so they could choose to answer in a more technical detail.
    2. Feel free to hint, brag, or both! The best CS reps should easily take a hint from clear language and a signature like John Appleseed, JavaScript/Ruby Developer, but any will catch on with a simple line like "I know what I'm doing, so I'd appreciate an extra-technical explanation!"
    3. Hey, I'm a PhD in [field] and do [whatever] professionally. Before calling you, I've narrowed down the problem to [something on their end], so that's what needs to be addressed. If I could speak to an engineer about [specific problem], that'd be great; but if we've gotta walk through the script, let's just knock it out quickly. If they end up requiring the script, then the best way to use your expertise is to run through it quickly. Keep the chit-chat to a minimum and just do the stuff efficiently. If they start describing how to perform some step, you might interrupt them with, "Got it, just a sec.", then let them know once you're ready for the next step.
    4. However, what speaks against just straight up telling them that you're working as [Insert title of your position] and you know what you're talking about?
    5. OP is referring to letting people know they can speak like proper adults when talking about technical terms, without going through the usual nanny-like discourse that tech support has to provide to non-techies. For instance, it happened to me with Amazon support. The speaker told me exactly where to touch in order to clear the cache of the Android Amazon App Store. Given that I work as an app developer the guy could have just said "please clear the cache". No need to go through "tap here, then here, now you should see this, tap that"...
    6. I have tried different tactics of showing the tech support that I am proficient in their field of work (I work as a web developer). Specifically: using accurate terms and technologies to show my knowledge of them and telling the support that I am the "administrator" of the website in question.
    7. How to let tech support subtly know that I am proficient without showing off?
    8. They have to ask you the dumb questions, either because their employer demands they do, or sometimes because their computer system doesn't let them get to the next part of the script unless they play ball.
    9. Another will employ smart people who apologise to you profusely for having to go through all the pointless steps, but that's just what they have to do!
    1. MJML has been designed with responsiveness in mind. The abstraction it offers guarantee you to always be up-to-date with the industry practices and responsive. Email clients update their specs and requirements regularly, but we geek about that stuff - we’ll stay on top of it so you can spend less time reading up on latest email client updates and more time designing beautiful email.
  15. Apr 2021
    1. John Company offers players a new understanding of British history in the eighteenth and nineteenth century that reflects contemporary scholarship on the subject and extensive research into primary documents. John Company attempts to put the critical events of that time in their proper context and show how the imperial experience transformed the domestic culture of Britain. The East India Company lurked behind every building of a textile mill and every bit of wealth in a Jane Austen novel.  John Company is an uncompromising portrait of the people who made the Company and the British Empire what it was. It is as frank as it is cutting in its satire.  Accordingly, the game wrestles with many of the key themes of imperialism and globalization in the eighteenth and nineteenth centuries and how those developments were felt domestically. As such, this game might not be suitable for all players. Please make sure everyone in your group consents to this exploration before playing. 
    2. If you'd like to read more about the game's arguments, click here. 

      I'm not familiar with this term "arguments" used like this. Isn't this more referring to the motivation for this game?

    1. It has two very different meanings, that you would have to distinguish by context. One meaning is just expressing that we have limitations. If you don't know something, that's just tough, you don't know it and you have to live with that. You don't have information if you don't have that information. The other meaning is that not only are there gaps in our knowledge, but often we don't even know what the gaps in our knowledge are. I don't know how to speak Finnish. That's a gap in my knowledge that I know about. I know that I don't know how to speak Finnish. But there are gaps in my knowledge that I'm not even aware of. That's where you can say "You don't know what you don't know" meaning that you don't even know what knowledge you are missing.

      I had this thought too.

    2. but in essence I expect OP means Rumsfeld's "unknown unknowns"
    3. But there are also unknown unknowns – the ones we don't know we don't know.
    4. We also know there are known unknowns; that is to say we know there are some things we do not know.

      known unknown

      like what?

    5. Some risk management techniques urge practitioners to consider the "known unknowns" and the "unknown unknowns"
    6. Incidentally, I'd add that it can also be used in looking toward the future, in awareness that we lack such a crystal ball: We base our plans on our knowledge, and there'll be times where we know there is a gap in that knowledge, but we're also aware that there may be things we can't possibly foresee, because "we don't know what we don't know".
    7. Yet, in all these instances, life offers no crystal ball; there's no way of knowing what the future holds, or to be cognizant of something we are unaware of. This is the essence of "You don't know what you don't know," only it's being expressed in a comical way
    8. Had I known the van was going to overheat, I would have driven the car instead.
    9. If I had known you were going to get such bad grades on your report card, I wouldn't have let you go to the dance last weekend.
    10. If I had known your plane was going to be two hours late, I wouldn't have rushed to the airport.
    1. Of course you must not use plain-text passwords and place them directly into scripts. You even must not use telnet protocol at all. And avoid ftp, too. I needn’t say why you should use ssh, instead, need I? And you also must not plug your fingers into 220 voltage AC-output. Telnet was chosen for examples as less harmless alternative, because it’s getting rare in real life, but it can show all basic functions of expect-like tools, even abilities to send passwords. BUT, you can use “Expect and Co” to do other things, I just show the direction.
    2. At first you feel confused because usual pipe constructions such as: $ echo luser && echo TopSecret | telnet foo.bar.com fail you and the problem which seemed so plain on the face of it grows into “mission impossible”.
    1. The privacy policy — unlocking the door to your profile information, geodata, camera, and in some cases emails — is so disturbing that it has set off alarms even in the tech world.

      This Intercept article covers some of the specific privacy policy concerns Barron hints at here. The discussion of one of the core patents underlying the game, which is described as a “System and Method for Transporting Virtual Objects in a Parallel Reality Game" is particularly interesting. Essentially, this system generates revenue for the company (in this case Niantic and Google) through the gamified collection of data on the real world - that selfie you took with squirtle is starting to feel a little bit less innocent in retrospect...

    2. Yelp, like Google, makes money by collecting consumer data and reselling it to advertisers.

      This sentence reminded me of our "privacy checkup" activity from week 7 and has made me want to go and review the terms of service for some of the companies featured in this article- I don't use yelp, but Venmo and Lyft are definitely keeping track of some of my data.

    1. Machinist was written because I loved the idea behind Factory Girl, but I thought the philosophy wasn't quite right, and I hated the syntax.
    1. The good news: everyone had a genuine blast. We knew we had experimented our way into something fun, even if the rules and designs still needed a lot of work.
    1. I actually think this is Not Constructive, since there's no absolute rule about which pairings can be joined into a single word or hyhenated, and it's pointless having "votes" here about each specific case. Follow a style guide if you have one, or search Google Books and copy whatever the majority do. Or just make your own decision.
    1. however, if this is relevant to just one spec, you don't necessarily need to include devise helpers to all your controllers specs, you can just explicitly include those helpers in that one controller describe block: require 'spec_helper' describe MyCoolController include Devise::TestHelpers it { } end
    1. Yes, you are right. That was a very bad workaround. Stubbing methods on NilClass can be compared to switching to dark side of force. Powerful but comes with a huge price. I highly don't recommend using my workaround from 1 year ago.
  16. Mar 2021
    1. If you've ever talked about regular expressions with another programmer, you've invariably heard this 1997 chestnut: Some people, when confronted with a problem, think "I know, I'll use regular expressions." Now they have two problems.
    1. 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
    2. 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.
    1. Or if you need to change the way the string is assembled, you can provide a proc, for example: if defined?(BetterErrors) BetterErrors.editor = proc { |file, line| "vscode://file/%{file}:%{line}" % { file: URI.encode_www_form_component(file), line: line } } end
    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. Small modules are extremely versatile and easy to compose together in an app with any number of other modules that suit your needs.
    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. 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. Better yet, send them a link to this page to help them understand why and how to make an example app:
    2. If you want the issue fixed as fast as possible, then you should try to help the maintainers as much as possible. Make an example app! Even if it takes extra time for you, it will ultimately lead to your issues getting fixed faster.
    1. The HTML5 form validation techniques in this post only work on the front end. Someone could turn off JavaScript and still submit jank data to a form with the tightest JS form validation.To be clear, you should still do validation on the server.
    1. Therefore client side validation should always be treated as a progressive enhancement to the user experience; all forms should be usable even if client side validation is not present.
    2. It's important to remember that even with these new APIs client side validation does not remove the need for server side validation. Malicious users can easily workaround any client side constraints, and, HTTP requests don't have to originate from a browser.
    3. Since you have to have server side validation anyways, if you simply have your server side code return reasonable error messages and display them to the end user you have a built in fallback for browsers that don't support any form of client side validation.
    1. 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

  17. Feb 2021
    1. URI::MailTo::EMAIL_REGEXP

      First time I've seen someone create a validator by simply matching against URI::MailTo::EMAIL_REGEXP from std lib. More often you see people copying and pasting some really long regex that they don't understand and is probably not loose enough. It's much better, though, to simply reuse a standard one from a library — by reference, rather than copying and pasting!!

    1. Since we're not passing any inputs to ListAccounts, it makes sense to use .run! instead of .run. If it failed, that would mean we probably messed up writing the interaction.
    2. ActiveModel provides a powerful framework for defining callbacks. ActiveInteraction hooks into that framework to allow hooking into various parts of an interaction's lifecycle.
    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?

    3. While you could nest an activity into another manually, the Subprocess macro will come in handy.
    4. The macro automatically wires all of Validate’s ends to the known counter-part tracks.
    1. 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. 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.
    2. That such minimalism is possible does not mean that it is necessarily desirable
    1. provide interfaces so you don’t have to think about them

      Question to myself: Is not having to think about it actually a good goal to have? Is it at odds with making intentional/well-considered decisions?  Obviously there are still many of interesting decisions to make even when using a framework that provides conventions and standardization and makes some decisions for you...

    2. You’re allowed to blame us for a terrible developer experience in Trailblazer 2.0. It’s been quite painful to find out which step caused an exception. However, don’t look back in anger! We’ve spent a lot of time on working out a beautiful way for both tracing and debugging Trailblazer activities in 2.1.
    1. In the short term you may have the stamina to get up earlier, stay later, and out-work the demands you face. But the inverse equation of shrinking resources and increasing demands will eventually catch up to you, and at that point how you involve others sets the ceiling of your leadership impact.
    1. Around 2 years ago I decided to end the experiment of “TRB PRO” as I felt I didn’t provide enough value to paying users. In the end, we had around 150 companies and individuals signed up, which was epic and a great funding source for more development.
    2. 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.
    3. The new call API is much more consistent and takes away another thing we kept explaining to new users - an indicator for a flawed API.