🗄️ Programming (uncategorized)

https://github.com/alexmojaki/heartrate

https://github.com/kivy/kivy

or maybe, that? … https://github.com/pfalcon/picotui

https://robotframework.org/

let's start with a real-life example from our web demo project. Here we have a test suite with one test case which tests that login is valid. As you can see, test data syntax is based on keywords.

https://github.com/blitzcode/rust-exp

https://github.com/Kobzol/hardware-effects

make sure you can generate sceleton easily and run from terminal

develop quick prototype and post in blog?

https://dev.to/sobolevn/9-best-open-source-findings-november-2019-gi0

And now I will show you something really unusual!
You can write thread-safe HTML/CSS/Python GUI framework. Wait, what? Yes, you heard it write. You can write your frontend in Python. It even supports Vue.js out of the box.
Written in Python.

https://dev.to/sobolevn/9-best-open-source-findings-november-2019-gi0

​​dovpanda
Linter for pandas. Finds errors and suggests improvements. Very helpful for ones who just start to work with data. Or teach how to work with it.
Written in Python.

The question: what are the conditions for the function A -> B to be a subtype of C -> D?

1. A is subtype of B means there is a special function castAB :: A -> B
2. Two casts compose into another casts, cast compositions are isomorphic (that is, castBC . castAB is essentially the same thing as castAC)
3. We wanna implement castAfB -> castCfD in order to show (A -> B) <: (C -> D)

  - X :: (A -> B) -> (C -> D)
  - we can only use functions applications and cast
  - X (fab :: A -> B) (c :: C) = ? :: D
  - the only thing we can do is to transform c to some another type, that is, we need castCT :: C -> T
  - now, we have (castCT c) :: T, basically, leaves us in the same situation, so, we actually need castCA :: C -> A
  - now, we have (castCA c) :: A, and (fab $ castCA c) :: B. The only way to get D is to use castBD :: B -> D

5. So, we have (A -> B) <: (C -> D), that is, A -> B is subtype of C -> D if C is subtype of A and B is subtype of D.


The return type (B and D) is covariant, since preserves the direction of <:
The argument type (A and C) is contravariant, since it flips the direction of <:


Container reading: covariant:

: S <: T, then ReadonlyCollection<S> <: ReadonlyCollection<T>

Container writing: contravariant:

: S <: T, then Consumer<T> <: Consumer<S>

- C++ poiners: covariant
- Java
  - arrays: covariant
  - Collection<? extends T>: covariant
  - Collection<? super T>: contravariant

I have found no exaggeration when people say that Rust, with the right crates, has an experience similar to Python when it comes to a "scripting experience". :) This is why ALL of my new projects have been in Rust for the last year.

How to Thank Me

• [2021-01-10] TLDR: both "I don't need tests" and "I don't need types" people are wrong, often because they haven't seen better alternatives
  

• Load balancer
  
• Scatter and gather
  
• Result cache
  
• map reduce
  
• Bulk requests
  

write-through: synchronous writes both to the cache and the backing store
write-back: initially, only in cache, write to backing store postponed until it's about to be modified/replaced

https://github.com/mre/awesome-static-analysis/

act -P ubuntu-latest=ubuntu:bionic
you can docker exec -it /bin/bash into the container and debug there

https://github.com/qawolf/qawolf

QA Wolf is an open source node library for creating browser tests 10x faster:
    Skip writing boilerplate. Your browser actions are converted to Puppeteer and Jest code.

https://mobile.twitter.com/voidlizard/status/1227505059963035648

I switched to NeoVim a few years ago and I'm not entirely sure whether Vim has caught up in features, diverged, or what ratio of the two.
That said, I'm not switching back. The only editor I'm really interested in is VSCode. Not that I use it much, but I am very impressed.

https://www.hillelwayne.com/post/why-tdd-isnt-crap/

While the first PBT library was Haskell Quickcheck, arguably the most sophisticated is the Hypothesis Python library.

https://news.ycombinator.com/item?id=21641760

https://github.com/karan/Projects

https://github.com/marketplace/actions/debugging-with-tmate
ok, nice it's like circleci ssh debugging.
less convenient because you have to commit a step, but ok considering you don't need it often

https://hacks.mozilla.org/

try typing in terminal with 30ms ping

Inversion of Control principle, which basically states that the flow of your application depends on the object graph that is built up during program execution, and such a dynamic flow is made possible by object interactions being defined through abstractions.
This run-time binding is achieved by mechanisms such as dependency injection or a service locator.

In 2008, I was extremely frustrated by Ruby imposing a constant ~100 ms startup penalty on hello world. In 2018, computers are ~3.5 times faster (4479 vs. 1266 Geekbench for 2007 vs. 2017 MBP). TypeScript imposes a 1600 ms startup penalty on hello world. https://t.co/GzMcXPoFNU

https://twitter.com/garybernhardt/status/1007690864909529088

Debugging multiple threads/processes

set follow-fork-mode [parent|child]
set detach-on-fork [on|off]

http://www.delorie.com/gnu/docs/gdb/gdb_26.html
http://sourceware.org/gdb/current/onlinedocs/gdb/Forks.html

https://sourceware.org/gdb/onlinedocs/gdb/Break-Commands.html

Awesome Fuzzing
Automated software testing technique that involves feeding pseudo-randomly generated input data.

https://twitter.com/awesome__re/status/1138001812718440448

https://www.rapidtables.com/web/color/index.html

https://github.com/cpuu/awesome-fuzzing#readme

Awesome Fuzzing

https://repl.it/repls/EmbellishedWanConcentrate
wow, nice

• D_GLIBCXXDEBUG
  

• https://stackoverflow.com/questions/2492020/how-to-view-contents-of-stl-containers-using-gdb-7-x
  

Get the python viewers from SVN
svn://gcc.gnu.org/svn/gcc/trunk/libstdc++-v3/python

Add the following to your ~/.gdbinit
python
import sys
sys.path.insert(0, '/path/to/pretty-printers/dir')
from libstdcxx.v6.printers import register_libstdcxx_printers
register_libstdcxx_printers (None)
end

You have to make sure that you have the package with the libstdc++ library compiled with the debugging flags.

For clang: -fno-limit-debug-info do not limit debug information produced to reduce size of debug binary

Libextract is a statistics-enabled data extraction library that works on HTML and XML documents and written in Python.
Originating from eatiht, the extraction algorithm works by making one simple assumption: data appear as collections of repetitive elements. You can read about the reasoning here.

huh, this is niiice!

https://twitter.com/EvMill/status/1314544492935032832

@EvMill: "The combination of virtues that Julia offers to the computational scientist expands the universe of things that can be accomplished in a finite time by a normal human. It allows the scientist to imagine things that might not be imagined without it."

Browsers: yes
https://github.com/sql-js/sql.js

https://github.com/mythmon/rust-nbodies

https://rickcarlino.com/2019/11/02/software-tools-for-hobby-sized-projects-html.html

Vultr - Dirt Cheap VPS Hosting
Since hobby projects rarely see high-volumes of traffic, the main concern is often cost rather than performance.

Vultr is my go-to solution for cheap hosting. As of this writing, the cheapest plan they offer is $2.50 a month. Although their cheapest plan defintely won’t be able to fuel your next high-powered computing project, it is a great solution when you need to host small scale tasks such as cron jobs.

    def get_extension_page_firefox(driver):
        moz_profile = Path(driver.capabilities['moz:profile'])
        prefs_file = moz_profile / 'prefs.js'

        # doesn't appear immediately after installing somehow, so need to wait for a bit..
        for _ in range(10):
            sleep(0.5)
            if prefs_file.exists():
                break

        addon_name = 'temporary_addon'
        # TODO ok, apparently I should add it to tips on using or something..
        addon_name = 'promnesia@karlicoss.github.com'

        addon_id = None
        for line in prefs_file.read_text().splitlines():
            # temporary-addon\":\"53104c22-acd0-4d44-904c-22d11d31559a\"}")
            m = re.search(addon_name + r'.....([0-9a-z-]+)."', line)
            if m is None:
                continue
            addon_id = m.group(1)
>       assert addon_id is not None

https://rickcarlino.com/2019/11/02/software-tools-for-hobby-sized-projects-html.html

MyJSON.com - Free Cloud Storage for JSON

https://github.com/hlissner/doom-emacs/blob/develop/docs/faq.org#how-do-i-change-the-leaderlocalleader-keys

Don’t be that guy who PRs 99 whitespace adjustments around his one-line contribution.

Regex cannot be used in expression for now,

for fucks sake, can't use regexes in github acitons pipelines?

https://www.happyhues.co/

https://bugjail.com/

https://github.com/awesome-selfhosted/awesome-selfhosted

API Management

Something that I’m surprised a lot of devs don’t know; there are official domains you’re supposed to use for documentation, testing, etc. They are specifically reserved by IANA for these purposes. Originally I think it was just example.com, but they now have a list of all them: https://www.iana.org/domains/reserved

https://duo.alexpate.uk/

https://thume.ca/2020/05/17/pipes-kill-productivity/

ok it works with CI now…

https://www.machinelearningplus.com/plots/top-50-matplotlib-visualizations-the-master-plots-python/

Still one of the best explanations of covariance vs contravariance, or consumers vs producers

The cookie law is not actually about cookies (and its not actually called the cookie law). Its about tracking users, storing and sharing the information with third parties. Cookies are just the most popular method to track users.
If you don't want to show the "cookie warning" then just don't track the users beyond the session and don't share traffic data with third parties.
The actual directive.

• bash works odd, powershell as well
  
• had to disable setup_requires=['setuptools_scm'] in setup.py, some ssl errors
  
• how to edit stuff? vim doesn't really work the quickes was git push/git pull
  
• shell history (with arrows) doesn't work
  

The simplest way to block specific IP address or ranges of them would be to set up a basic firewall using UFW. It is included with Ubuntu by default.
You can then block a specific IP address by running:
    sudo ufw deny from XXX.XXX.XX.XX

Prolific rr contributor Keno Fischer has a great writeup of how the Julia project is integrating rr to capture user bugs.

http://matt.might.net/articles/programming-with-continuations--exceptions-backtracking-search-threads-generators-coroutines

https://twitter.com/yoshikischmitz/status/1279566482188333056

@yoshikischmitz: Are there any apps out there for quickly filtering arbitrary lists of data w/ a simple "reject" and "accept" gesture? Thinking of something like Tinder but I make the cards, and can get a list of the accepted ones.

https://github.com/pavelfatin/toyide

http://nickgravgaard.com/elastic-tabstops/

https://opensourcedesign.net/

https://codeburst.io/web-scraping-in-rust-881b534a60f7

I don’t write tests to avoid bugs. I write tests to avoid regressions.

https://hackernoon.com/guide-to-web-automation-889557804453

http://blog.stuffedcow.net/2019/09/hard-disk-geometry-microbenchmarking/
very impressive and thorough analysis
lots of detailed plots and pretty clear explanations

I bring this up every time someone thinks “full code coverage” means anything at all, but:

double sin(double x) {
  return x;
}

void testSin() {
  assert( sin(0) == 0 );
}

https://twitter.com/stephentyrone/status/1073795608819855367

https://github.com/stedolan/jq/issues/694

You have fallen in the main trap in jq: the comma IS NOT an arguments separator in function calls.
Allways use the semi-colon!

https://blog.apify.com/web-scraping-in-2018-forget-html-use-xhrs-metadata-or-javascript-variables-8167f252439c

This approach can be used for scraping data from Airbnb. You don’t even need to open the page in a headless browser, you just need to get the token first and then use their API:

https://github.com/scrapinghub/portia

Portia is a tool that allows you to visually scrape websites without any programming knowledge required. With Portia you can annotate a web page to identify the data you wish to extract, and Portia will understand based on these annotations how to scrape data from similar pages.

https://gist.github.com/alecxe/fc1527d6d9492b59c610

https://spacy.io/

https://github.com/public-apis/public-apis

https://gregoor.github.io/syntactor/

https://search.google.com/test/mobile-friendly

• DI is just a fancy term for using constructors (25 dollar concept…)
  
• DI can be easily misused
  
• DI doesn't require a library/framework
  
• DI library/framework helps with the wiring mess
  

https://github.com/dariusk/corpora

This project is a collection of static corpora (plural of "corpus") that are potentially useful in the creation of weird internet stuff. I've found that, as a creator, sometimes I am making something that needs access to a lot of adjectives, but not necessarily every adjective in the English language. So for the last year I've been copy/pasting an adjs.json file from project to project. This is kind of awful, so I'm hoping that this project will at least help me keep everything in one place.

Most of this advice is stuff they tell you in school that doesn’t matter at all in reality.
Real advice:
- Normalize until it hurts, denormalize until it works. (I.e. prefer normal forms but denormal will have better performance.)
- You need nullable dates and nullable numbers. You never need a nullable string. If you must distinguish blank string from unset, add a column called “unset”. Using null for this will just result in bad data entry.
- Names should be stored as display_name, first_name, and last_name. A display name is not the same as just first plus last. They have different purposes, so don’t shove them together.
- When in doubt, just have a column full of JSON and figure it out later.
- Offset pagination is bad for performance. Avoid it at all costs unless you want some spider indexing page 10,432 of your archives to eat all your CPU.

https://www.scrapingbee.com/blog/web-scraping-without-getting-blocked

I've always liked this example, from _Practical Common Lisp_ (2007).
> `DOLIST` is similar to Perl's `foreach` or Python's `for`. Java added a similar kind of loop construct with the "enhanced" `for` loop in Java 1.5, as part of JSR-201. Notice what a difference macros make. A Lisp programmer who notices a common pattern in their code can write a macro to give themselves a source-level abstraction of that pattern. A Java programmer who notices the same pattern has to convince Sun that this particular abstraction is worth adding to the language. Then Sun has to publish a JSR and convene an industry-wide "expert group" to hash everything out. That process--according to Sun--takes an average of 18 months. After that, the compiler writers all have to go upgrade their compilers to support the new feature. And even once the Java programmer's favorite compiler supports the new version of Java, they probably still can't use the new feature until they're allowed to break source compatibility with older versions of Java. So an annoyance that Common Lisp programmers can resolve for themselves within five minutes plagues Java programmers for years.

We don't need new languages without features: it has already been proven that you only need exactly one feature in your programming language to write any program possible. Look up single instruction languages for proof that it is possible and such single features languages exist.
What we need are languages with many features that are easy to use to create complex programs that are still easy to understand.

https://automatetheboringstuff.com/
I guess it's good for other people who are not that good in programming, but I know all of it already

https://www.reddit.com/r/cpp/comments/9cndcr/lldb_now_supports_syntax_highlighting/e5c63eg/

Sure, the thing that first showed me that gdb is more than just a console debugger you can use over ssh was this video few years ago:
CppCon 2015: Greg Law " Give me 15 minutes & I'll change your view of GDB"

Apache Arrow is a nice in-memory data structure finding its usage in wide variety of projects; especially in data science due to its feather format which can be used to save data frame from memory to the disk.

FAQ about displaying stuff in a terminal

 messed around with awk and came up with this script:

```
NR > 1 { printf (/DEBUG/ && hiding) ? "\r" : "\n" }
{ printf "%s", $0; hiding=/DEBUG/ }
END { printf "\n" }
```

It advances to a new line only if the current and previous lines didn't have DEBUG.

PrettyErrors does only one thing and does it well. In terminals that support colored output, it transforms the cryptic stack traces into something that is much better suited for parsing with our puny human eyes. No more scanning the entire screen to find the culprit of your exception… You can now find it at a glance!

1. For manual editing, dot -Tx11 foo.dot displays the graph in a window and updates it automatically whenever you save. So you can have an editor window open and the dot window and see the results of every tweak.

https://buttondown.email/hillelwayne/archive/a-totally-polished-and-not-at-all-half-baked-take/

https://buttondown.email/hillelwayne/archive/a-totally-polished-and-not-at-all-half-baked-take/

No, dynamic type systems are not inherently more open, by Alexis King. King is a PLT (programming language theory) researcher and an expert in both static and dynamic languages,

Quick summary: - real time collaboration - integrations (databases, S3 buckets, environment variables) - persistent (and much much faster) filesystem - hardware doesn't shut off - many more features like variable explorer or automatic visualizations - much nicer interface so you can share with non-technical people - paid plan so you can build your data science team around it - no GPU/TPU machines yet, but that's coming

deepnote vs google colab

Implementing Rust's dbg! in Python

In this article
    Running a workflow on GitHub
    Running a workflow using the REST API
To run a workflow manually, the workflow must be configured to run on the workflow_dispatch event. For more information, see "Events that trigger workflows."

Виталий Брагилевский (@_bravit) Tweeted:
@SrgGrch У программистов одна проблема — они тупые. Цель разработчиков языков программирования в том, чтобы этот факт не сильно мешал. https://twitter.com/_bravit/status/1130567953118834688?s=17

https://twitter.com/OhTheAnguish/status/1089461515273621504

kina like in MC?
https://github.com/pixelb/crudini/issues/33#issuecomment-240365862

there is no easy way to self distribute extensions

• CWR reviews take ages, also tedious to figure out, especially in the early dev stage
  

users have to do it manually

• users that are not logged in are not allowed to see the artifacts
  both github actions/circle ci
  
• alternative
  imagine if instead of that crap, APIs etc, I could simply copy a file to a shared filesystem or something.
  

debugging is impossible, it's some typescript shit that's unclear how to debug

I'm sure I'm missing out some imortant context, so please point me

https://subredditstats.com/subreddit-user-overlaps/fossdroid
build a tool that collects all your subreddits (bookmarklet??) oe just ask to copy list, queries them and shows new ones

run build on matrix, then deploy artifacts.

I want for all builds to succeed, then deploy

# fuck me. https://help.github.com/en/actions/reference/workflow-commands-for-github-actions#adding-a-system-path
- run:
    echo "::add-path::$HOME/.local/bin"

at least now I can use pip install –user!

Using - as a filename to mean stdin/stdout is a convention that a lot of programs use. It is not a special property of the filename. The kernel does not recognise - as special so any system calls referring to - as a filename will use - literally as the filename.

https://github.com/tulir/mautrix-facebook/wiki/Bridge-setup-with-Docker

@Glench: @karlicoss Don't forget that this already exists in Gmail.js! https://t.co/zd1dc63Xxy

https://twitter.com/tryolabs/status/1341076817277562880

This library helps discover correlations and patterns in high-dimensional data using parallel plots and other graphical ways to represent information. https://t.co/0OAaa25OrB

A Smart, Automatic, Fast and Lightweight Web Scraper for Python

https://twitter.com/rsnous/status/1346944636145684488

@rsnous: i think people overrate the difficulty of doing a FUSE filesystem because it's exotic; it might not actually be that much harder than making a usable CLI or a reliable file-tree-watching thing. when you make a filesystem, you don't have to design a frontend, for instance

Extensible memoizing collections and decorators

A scraping command line tool for the modern web 

(seems that not updated)

Schema.org is a collaborative, community activity with a mission to create, maintain, and promote schemas for structured data on the Internet, on web pages, in email messages, and beyond.

A new way to develop parsers for binary structures.
Declarative: describe the very structure of the data, not how you read or write it
Language-neutral: write once, use in all supported languages:

graphql api explorer?

https://github.com/tiangolo/fastapi

Interactive API docs
Now go to http://127.0.0.1:8000/docs.

You will see the automatic interactive API documentation (provided by Swagger UI):

Write less code
The most important metric you're not paying attention to

News, full-text, and article metadata extraction in Python 3

https://twitter.com/relizarov/status/1134190090547281920

All-new Jupyter Notebooks

Set up DNS

cache

Provided Portia is no longer been offered by Scrapinghub, I think the company is no longer funding the maintenance of this project.
Source: https://support.scrapinghub.com/support/solutions/articles/22000200405-which-services-are-available-on-scrapy-cloud-

Next I decided to crack open VTune. Here the difference was revealed plain as day!

snovv_crash 4 minutes ago [-]
Event driven architecture is like GOTOs but with data instead of execution flow. Throw your data to the wind, someone somewhere will handle it (I hope).

Step-by-step example of reverse-mode automatic differentiation

good explanation of automatic differentiation

"When will you learn? Closures are a poor man's object."

awk
This was a tool written by three of the smartest people in the field at the time (Aho, Weinberger, Kernighan) to solve a problem they had often.
awk is still an excellent tool for exploring unstructured, semi-structured, and record-based data, and can be abused for lots of other use cases. Despite it’s age, it still includes many features that people expect from modern languages (hash tables, not having to pre-declare variables, easy use of regexes). If you know awk, you can throw out a lot of other shell tools, such as grep, cut, head, tail, and many more. Where I might have reached for a dozen or two line Python script, I often just write a dozen or two characters of awk.
“The AWK Programming Language” is one of the clearest and most concise technical books I’ve ever read, and definitely the best ROI I’ve gotten from reading any book.

Fun fact: if you’re reading this article, you’re using the distributed web. Since mid-February 2019, this blog, With Blue Ink, has been served through IPFS and the Cloudflare Distributed Web Gateway.

https://twitter.com/kieranmch/status/1218294511027269632

Not a native speaker here. What’s an alternative for whitelist/blacklist?
Allow list and block list
Which is also more descriptive than white/black list. It tells you what it does!

https://twitter.com/kieranmch/status/1218294511027269632

Interested to know what you use rather than master/slave and black/white list
Kieran McHugh
@kieranmch
Depends on context, but Primary/Replica is an example. Instead of saying “merchant whitelist” I would say “allowed merchant list”.

The ignore crate provides a fast recursive directory iterator that respects various filters such as globs, file types and .gitignore files. The precise matching rules and precedence is explained in the documentation for WalkBuilder.

Since Linux 3.15, the new renameat2 system call can atomically exchange two paths on the same file system. However, there’s not even a glibc wrapper for it yet, let alone a coreutils way to access it.

OPEN-SOURCE SOFTWARE
Molecular FLipbook is a free and open-source molecular animation program. The animation toolkit is based on the GPL-license Blender Game Engine.

The ever-growing Libarynth is almost exactly what its name implies – a hybrid between a library and a labyrinth, a maze of pages in various stages of completion.

Writing Python inside your Rust code

Strings Shouldn't Be Iterable By Default

fucking yaml..

ts: timestamp standard input

The solution is to use tabs for indentation but spaces for alignment. So for the second line of your code example, tabs would be used up to the indentation level of int, and spaces would be used from that point on to align float.

https://twitter.com/sigfpe/status/1174089914897453056

There is a sense in which automatic integration has been completely solved.

https://twitter.com/b0rk/status/1197282185230860288

hinking about what makes programming exercises good. So far I have:
** I can easily see how it relates to my life
** I learn something new
** I can do the exercise in less than 3 hours
** No complicated setup required

https://twitter.com/hillelogram/status/1247614748419592192

What testing/checking strategy SQLite follows?
Hillel
@hillelogram
All of them

https://sqlite.org/testing.html

“Rolling out one’s own programming language” is a very common fallacy in software development. It struck hard many projects where the configuration or programming language was:

    limited in expressiveness and features;
    yet another language to learn (but not something very useful and reusable) which requires some effort on the user end and thus creates an entry barrier;
    harder to read (at least at the beginning);
    and often with poor performance.

relevant to configs-suck

The fundamental difference between Rust's approach and Java-style checked exceptions arises when those three functions have different error types. In Java, you would annotate the function with every possible exception that the function can throw. In Rust, a library (or module with a library) would normally design its own Result type to encompass every error that the library/module can throw, and use that type on every error-producing function (you could reproduce the Java approach by defining a new Result type for each function, but I've never seen anyone bother with that).

And by using LD_PRELOAD magic, this can even be retrofitted onto existing applications without changing or recompiling them.

"We announce the release of a @ProjectJupyter
 kernel for SQLite, which supports the complete SQLite syntax as well as some extra operations such as opening or closing database files, or visualizing the data in different ways using Jupyter magics."

Here's a visual comparison of the data structures underlying three different "collaborative text editing" algorithms.
- yjs uses a doubly-linked list of nodes
- mine uses a tree
- automerge uses a transaction log (and has in-memory caches for perf)

• demonstrate how black messes it up
  
• suggest the rule to disable it
  

vdash@types.pl - Subtyping is good, state is fine when used with care, inheritance is a Bad Plan, composition is a Good Plan, algebraic datatypes are objectively morally correct. I can't think of any more takes

• chocolatey
  
• vs code
  
• git + can use bash inside git
  

Not an Athens developer, but hopefully can give some general advice..
Generally open source projects welcome contributions, especially if the contribution complies with project guidelines, covered with tests, doesn't contain unrelated changes, etc.. However there are some things to consider:

One of the biggest factors is maintainer's time, and often guiding a person to improve their code takes more time & energy than implementing the same from scratch.
I guess for this the only advice is to read guides carefully, search stuff & ask elsewhere if possible, so you would ideally only ask the maintainers for things specific for the project.
Basically whatever you would do in general when you're doing independent learning. Although of course the author might be happy to guide you for small things -- which is great too. But good to keep this in mind.

Another factor to keep in mind is that the developers might want to keep the project compact and minimal in terms of features.
The reason is that generally the more features you have, the more code you have ===> the more likely it would break which is a burden on the maintainer.
Plus depending on the project features that maintainer isn't using themselves would end up poorly tested (yet another reason to make sure you have tests with your contribution if possible).
To avoid this it's best to ask the maintainers whether the feature would be welcome in advance. It's very sad to work on something for a week to find out they don't want to merge it. In some cases you can work off a fork, but not always.

Apart from this, I can't imagine the cases when bugfixes or extra test coverage won't be welcome. Which could also be a great way to get familiar with a new project (or even programming language!).

E.g. integrate with guthub, but use custom software for it

• [2021-03-15] so the idea that it's similar to R's ggplot2 which uses 'grammar of graphics', apparently very declarative and compositional?
  

Write your apps in Python and release them on iOS, Android, Windows, MacOS, Linux, Web, and tvOS using rich, native user interfaces

some nice CRDT illustrations

new link https://programmingisterrible.com/post/139222674273/how-to-write-disposable-code-in-large-systems

Accidentally stayed up until 7am on a videocall with @girba
 learning about Pharoah Smalltalk and #gtoolkit
Have not been this excited about a new programming paradigm since I learned Clojure.
Amazing amazing tool they have, with almost no on-boarding yet.

acquire/release синхронизированные доступы, частичные гарантии на ordering, без sequential consistency, средне тяжелые на железе
volatile сигхронизированные доступы, полные гарантии ordering, sequential consistency, очень тяжелые на железе

class Car {
  public Car(Engine *engine) {
  }
}

class SportCar extends Car {
  public SportCar() {
    super(new SuperSportEngine());
  }
}

essentially Pimpl, but implementations might be different

Annotations can be allowed to only live in compile time
Annotations are not inherited (e.g. if A is Serializable and B extends A, B is automatically Serializable, which might not be the case)
Annotations have to be checked with reflection, whereas marker interfaces can be checked by compiler

Jigsaw: modules
Immutable collections
new HTTP module (+websockets?)
jshell
process control
Varhandles?

B extends A
C extends B

List<? extends A> could be a List<A> or List<B> or List<C>

void consumer(List<A> list);

if we want to pass List<B> to consumer, we have to create a new list since lists are not covariant on the argument type

solution: void consumer(List<? extends A> List)

• can be named
  
• you can cache objects
  
• extra validation:
  no simple way to validate input before delegating this call
  

DeleteMessagesTask(@NonNull AccountComponent accountComponent, @NonNull Bundle bundle) {
  final SolidList<Message> messages = bundle.getParcelable(KEY_MESSAGES);
  // TODO throw if null? maybe something specific, not just NPE?
  assert messages != null;
  this(accountComponent, messages);

go to your fork https://github.com/karlicos-test12/pymplate/actions, click "I understand my workflows, go ahead and enable them"
https://github.community/t/workflow-isnt-enabled-in-repos-generated-from-template/136421
ok, pypi would fail presumably… https://github.com/karlicos-test12/pymplate/runs/2047882422?check_suite_focus=true

or lightweight promnesia marks?

In my opinion, one killer feature of VSCode is the ability to connect to WSL, remote server and Docker container.
As someone mainly developing on WSL2, I use this feature everyday. I only use Idea when I need to use Java or Kotlin, because its language support is really good.

    echo '' | fzf --print-query --preview 'jq {q} input.json'
This was posted the last time this came up.

grep -oP 'foobar \K\w+' test.txt

extract match only with grep

Beginning with version 3.22.0 (2018-01-22), a read-only WAL-mode database file can be opened if the -shm and -wal files already exists or those files can be created or the database is immutable.

https://github.com/willmcgugan/rich

Approaching version 1.0 of Meetable, my open source events ... • Aaron Parecki
Today I worked on streamlining the installation process for Heroku, and it’s now installable in under 5 minutes, no command line required! Try it out! meetable.org

"Hosting SQLite databases on Github Pages" is absolutely brilliant: it adds a virtual filesystem to SQLite-compiled-to-WebAssembly in order to fetch pages from the database using HTTP range requests https://phiresky.github.io/blog/2021/hosting-sqlite-databases-on-github-pages/

https://news.ycombinator.com/item?id=26813725

A [condition system](https://en.wikipedia.org/wiki/Exception_handling#Condition_systems) **built atop** [**multi prompt delimited continuations**](https://www.google.com/search?q=%22multi-prompt+delimited+continuations%22).
These two ingredients (*condition system* and *multi prompt delimited continuations*) first emerged (separately) in the 1980s or thereabouts.
I foresee them re-emerging in new programming languages in the 2020s, kicked off by the incorporation of multi prompt delimited continuations into the Java run-time. (A Java condition system will then naturally emerge.)
Note the formal correspondence between multi prompt delimited continuations and algebraic effects.
You might be interested in a thread from this sub a few months back titled [Is there any interesting work on how to handle errors in code?](https://www.reddit.com/r/ProgrammingLanguages/comments/buged8/is_there_any_interesting_work_on_how_to_handle/) which covered roughly the same territory as this thread but with quite different commentary.
From my perspective this isn't really about errors. I wrote [a long comment](https://www.reddit.com/r/ProgrammingLanguages/comments/buged8/is_there_any_interesting_work_on_how_to_handle/epdpjjp/) in the above linked thread that explained my perspective. (NB. The recently released new language mentioned in that comment was renamed a couple weeks ago to *Raku* to try stop people incorrectly jumping to conclusions about it based on its name rather than its technology. Here's [its new blog](https://rakudoweekly.blog/blog-feed/).)

Foundations of Game Engine Development, Volume 2: Rendering (FGED2) is now available on most Amazon websites worldwide!