Furthermore, our research demonstrates that the acceptance rate rises over time and is particularly high among less experienced developers, providing them with substantial benefits.

Engagingwith the slip box should feel exciting, not anxiety-producing.

Latticework’s main goal, then, is to enable fluid movement between these foraging and sensemaking stances. By extension, that means fluid movement between acting on source documents (which emphasize foraging) and on your working document (which emphasizes sensemaking)

When processing an item in your in list the first question you need to ask is: is it actionable?—in other words, do you need to do something? If the answer is NO, you either throw it away if you no longer need it, keep it as reference material (“I will probably need this article again some day…”), add it to a some day/maybe list (for things like “learn Indonesian”), or incubate it. Wait, what‽ Sit on it? Yes, sort of. If it’s something that you want to remind yourself about later (“I really didn’t understand this article, I should have a look at it again in two weeks”) it should go into your calendar or your tickler file which will soon be explained. (Yes, even the weird name.)

Open a new tab in your Chrome browser and type chrome://flags in the search field

Our flow is: The reporter reports an issue, and we developers create sub tasks upon that issue... in Redmine, we also had a percentage graph that would reach 100% when all sub-tasks were completed, was a great way about checking 1 item without the need to drill down all subtasks.

The comparison to MRs is a good one, because MRs have a distinct workflow and JTBD. As such, they are their own object record. I'm not sure whether a decision to move them to work items has been made, but I can see a case for and against.

My Python Emacs Workflow

流程中的节点往后传递参数非常简单，只需往控制台输出即可。但须注意，多个控制台输出会合并到一起，因此除了往后传递参数外，其他情况下都不要往控制台打印文本。通常控制台输出会包含换行符，为避免换行符带来干扰，推荐使用 echo -n（bash） 或 sys.stdout.write（python）；直接执行 js 时，方法内部的return 即往后传递参数，此时 console.log 输出到控制台并不合法。

日常生活中，在微信订阅号列表，或者是好友的群聊中看到不错的文章，直接转发给 Wechat 2 Reader，将文章收藏到 Readwise Reader。

Perhaps tools like ChatGPT signal the start of a revise revolution in OER creation, where the role of an OER creator starts not with creating content but with creating the correct prompts to generate a first draft of content, then spends the bulk of their time revising and validating the content.

development host for debugging, to a staging environment for tests, and finally to production to release an update

So these are our two goals with organize. A, that the information is organized well. What you want to have happen here is that you can very quickly get the gestalt of what’s on your plate, what’s due, what’s not, who you’re waiting to hear back from. The information is put aside in such a way that it’s not just a list with a hundred things. And two, all the relevant information is there. I’m not scrambling around to figure out what I need to know to do this thing. All the information is there.

Now, not every programmer prefers that kind of development. Some programmers prefer to think of development as a process of designing, planning, making blueprints, and assembling parts on a workbench. There’s nothing wrong with that. Indeed, a multibillion-dollar international industry has been built upon it.

In fact, there’s a style of programming, well known in Lisp and Smalltalk circles, in which you define a toplevel function with calls to other functions that don’t yet exist, and then define those functions as you go in the resulting breakloops. It’s a fast way to implement a procedure when you already know how it should work.

These notes have no value except as stepping stones for turning literature notes into permanent notes. You discard the fleeting notes once you transformed them into permanent notes (more on that in level 3).

coordination can be defined as the arrangement of actions across people,places and times so as maximize synergy and minimize friction. In earlier work (Heylighen, 2012b),we have analyzed coordination into four components: alignment, division of labor, workflow andaggregation.

Service Catalog and Workflow Overview

process

A good workflow can easily turn into a virtuous circle, where the positiveexperience motivates us to take on the next task with ease, which helps us toget better at what we are doing, which in return makes it more likely for us toenjoy the work, and so on. But if we feel constantly stuck in our work, wewill become demotivated and much more likely to procrastinate, leaving uswith fewer positive or even bad experiences like missed deadlines. We mightend up in a vicious circle of failure (cf. Fishbach, Eyal and Finkelstein,2010)

My process for collecting and synthesizing information used to be exactly that: make highlights, sync them to Roam, tag the articles’ pages, and the respective blocks/highlights. And when it was time to write I would think of applicable tags for drafting the outline of an article, open their linked references in the sidebar, drag relevant ones into the outline, and draft the manuscript.

Whenever I get a new cookbook, I go through it and bookmark recipes that are either worth considering, or that go on a list to definitely try. Usually the maybes outnumber the definites. In this case, I've bookmarked a large number of recipes that I DEFINITELY will make.

Solution The goal should be to use Markdown on git as the source of the documentation by default. This will make version control possible and facilitate collaboration. To achieve this, the first step should be to export all the InDesign files to Markdown, going through HTML. This page explains how to export InDesign to HTML Once the HTML files have been generated, converting them to markdown requires Pandoc. Help the client install Pandoc following this guide There is also a web version of Pandoc Some markdown editors like Atom export HTML into markdown Assuming the HTML file that needs to be converted is named file.html and the Markdown file the client needs to generate should be called file.md, the command to convert HTML to markdown is this: pandoc -o file.md file.html Once all the HTML files have been converted to markdown, the client can start updating their files directly in the git repository. Markdown files can then be imported into InDesign going through HTML whenever the client feels they can consolidate one version into a PDF or print. To export Markdown into HTML Pandoc can be used again, but also editors like Atom or ReText export markdown into HTML. This time the command in pandoc will be: pandoc -o file.html file.md ( assuming the Markdown file that needs to be converted is named file.md and the HTML file the client needs to generate should be called file.html). A howto for importing HTML to InDesign Instead of the Python script included in this article to delete new lines in the HTML file (which doesn’t seem to work), we can send the client this script in bash. The script can be launched on a Linux machine (it should also work in a Mac terminal). Instructions for the client: Download the attached file to the folder where you have saved your HTML files. You can open the file with a text editor to check that all is ok. You can also find the script here: https://github.com/AccessNow/helpline_documentation_resources/blob/master/scripts/sed-clean-HTML.sh allow the script to be executed, by running this command: chmod 777 sed-clean-HTML.sh run this command on all your files: ./sed-clean-HTML.sh filename.html

Marked has a basic AppleScript dictionary, and allows you to get the document filename from multiple windows, as well as open files from scripts. This allows some workflow integration if you know a little bit of AppleScript. You can have any application which can trigger an AppleScript open a document in Marked, or have it retrieve a document from Marked for editing or other actions.

Additional testing of pipeline portability is currently being conducted as a part of the Global Alliance for Genomics and Health (GA4GH) workflow portability challenge

Better community building: At the moment, MDN content edits are published instantly, and then reverted if they are not suitable. This is really bad for community relations. With a PR model, we can review edits and provide feedback, actually having conversations with contributors, building relationships with them, and helping them learn.

Better contribution workflow: We will be using GitHub’s contribution tools and features, essentially moving MDN from a Wiki model to a pull request (PR) model. This is so much better for contribution, allowing for intelligent linting, mass edits, and inclusion of MDN docs in whatever workflows you want to add it to (you can edit MDN source files directly in your favorite code editor).

I'd like to go with an RFC-based governance model (similar to Rust, Ember or Swift) that looks something like this: new features go through a public RFC that describes the motivation for the change, a detailed implementation description, a description on how to document or teach the change (for kpm, that would roughly be focused around how it affected the usual workflows), any drawbacks or alternatives, and any open questions that should be addressed before merging. the change is discussed until all of the relevant arguments have been debated and the arguments are starting to become repetitive (they "reach a steady state") the RFC goes into "final comment period", allowing people who weren't paying close attention to every proposal to have a chance to weigh in with new arguments. assuming no new arguments are presented, the RFC is merged by consensus of the core team and the feature is implemented. All changes, regardless of their source, go through this process, giving active community members who aren't on the core team an opportunity to participate directly in the future direction of the project. (both because of proposals they submit and ones from the core team that they contribute to)

The RFC repo (where the reaction was strongly positive) is the place for discussion about what features to add; the decision has been made.

separate the workflow description from its execution.

And because it's real CSS, rather than some camelCased quotes-everywhere impostor, we can take advantage of the 'tweak in devtools, paste back into our source code' workflow, which I personally couldn't live without.

Yarn also has an RFC process which may offer a better discussion platform compared to this GitHub issue.

Many changes, including bug fixes and documentation improvements can be implemented and reviewed via the normal GitHub pull request workflow. Some changes though are "substantial", and we ask that these be put through a bit of a design process and produce a consensus among the Yarn core team. The "RFC" (request for comments) process is intended to provide a consistent and controlled path for new features to enter the project.

Ultimately though, I'd say the file structure that makes the most sense for your i18n workflow is the best one.

Archiving and downloading annotations Annotation viewing and export, from Hypothesis Labs Link: https://jonudell.info/h/facet Screencast: https://jonudell.net/h/facet.mp4 Description:  View annotations by user, group, URL, or tag. Export results to HTML, CSV, text, or Markdown.

However, it did require us to think differently about the creation, maintenance, and sustainment of our components moving forward — an integrative process we call "storybook-driven development."

These protocols, formal structures, plans, procedures, and schemes can be con-ceived of asmechanismsin the sense that they (1) are objectified in some way(explicitly stated, represented in material form), and (2) are deterministic or at leastgive reasonably predictable results if applied properly. And they aremechanisms ofinteractionin the sense that they reduce the complexity of articulating cooperativework.

Therefore, instead of pursuing the elusive aim of devising organizational modelsthat are not limited abstractions and thus in principle brittle when confronted withthe inexhaustible multiplicity of reality, organizational models in CSCW applica-tions should be conceived of asresourcesfor competent and responsible workers.

Exceptions are normal in work processes.

Re-open libraries for exploration I use in-ns to jump into library namespaces and re-define their vars. I insert bits of println statements to help understand how data flows through a library. These monkey-patches only exist in the running REPL. I usually put them inside a comment form. On a REPL restart, the library is back at its pristine state. In this example below, I re-open clj-http.headers to add tracing before the header transformation logic: [source] ;; set us up for re-opening libraries (require 'clj-http.headers) (in-ns 'clj-http.headers) (defn- header-map-request [req] (let [req-headers (:headers req)] (if req-headers (do (println "HEADERS: " req-headers) ;; <-- this is my added print (-> req (assoc :headers (into (header-map) req-headers) :use-header-maps-in-response? true))) req))) ;; Go back to to the user namespace to test the change (in-ns 'user) (require '[clj-http.client :as http]) (http/get "http://www.example.com") ;; This is printed in the REPL: ;; HEADERS: {accept-encoding gzip, deflate} An astute observer will notice this workflow is no different from the regular clojure workflow. Clojure gets out of your way and allows you to shape & experiment in the code in the REPL. You can use this technique to explore clojure.core too!

We'll first look at modelling the problem space - what is common to, and what differs between, thedifferent product variants. Then we'll consider one possible approach for realising product variants in the solutionspace using C++ as an example. Finally we'll look at how Application Engineering is performed by using theproblem and solution space models to create a product variant.

In reality, this linear flow is rarely found in practice.Product Lines usually evolve continuously, even after the first product variants have been defined and deliveredto customers.

Data becomes dark because no one is paying attention. There is little professional reward structure for scientists to preserve and disseminate raw data. Scientists are rewarded for creating high-density versions of their data in statistics, tables, and graphs in scholarly journals and at conferences. These publications in some ways are the sole end product of scientific inquiry. These products, while valuable, may not be as useful as some authors hope.

Traders continue to monitor their open positions and look for any more opportunities.

If everything is working properly, traders start scanning the markets for potential trading opportunities.

After reading about events and making note of what the analysts are saying, traders head to their workstations, turn on their computers and monitors and open up their analysis and trading platforms.

Traders will also review economic calendars to find out which market-moving financial reports – such as the weekly petroleum status report – are due that day.

This involves reading stories from various newspapers and financial websites, as well as listening to updates from financial news networks, such as CNBC and Bloomberg.

Who Owns Digital Science?

“workflow is the new content.”