mizchi

// unofficial sqlite3 types.
// These are typed only for my scope

declare module "@sqlite.org/sqlite-wasm" {
  type InitOptions = {
    print: (...msg: any[]) => void;
    printErr: (...msg: any[]) => void;
  };

  declare type PreparedStatement = {

tomsing1

---
title: "Experimenting with SQLite"
editor_options: 
  chunk_output_type: inline
---

```{r}
library(glue)
library(RSQLite)
library(jsonlite)

riyaz-ali

-- The following snippet calculates the extended internal rate of return
-- for an investment, provided the list of transactions made during the time.
-- 
-- It expects a table `transactions` to be present (of-course feel free to rename)
-- with two columns, date and amount, where date is the date of the transaction
-- and amount being the amount of the transaction. Each outflow (like, money put into the investment)
-- must be a negative value and each inflow (like, money take out from investment) must be positive.
--
-- P.S. This snippet depends on POWER(...) function from [https://github.com/nalgeon/sqlean].
--      Either import that or provide your own.

asardaes

Gradle plugins require a marker:
https://docs.gradle.org/current/userguide/plugins.html#sec:plugin_markers

Markers aren't published for precompiled scripts using groovy-gradle-plugin :(
https://github.com/gradle/gradle/issues/15190

The plugin_marker module creates the marker that Gradle needs to find the plugin and also publishes it,
see https://stackoverflow.com/a/60798021/5793905

Assuming all gradle modules have the same group with a folder structure like:

danteese

/**
 * Map function to get all the results from the database
 * this is specially useful if you're trying to access to
 * the questions and options as you may want to generate 
 * a report in your system...(not only the answers)
 *
 * I mainly did this because of the lack of good examples 
 * on the documentation, only through other github projects
 * and try and failure.
 *

CatsMiaow

/**
 * https://github.com/GoogleChromeLabs/comlink/blob/master/docs/examples/06-node-example/main.mjs
 * https://github.com/GoogleChromeLabs/comlink/issues/476#issuecomment-642765445
 * esModuleInterop to true in tsconfig.json compilerOptions.
 */
import { Worker } from 'worker_threads';
import * as comlink from 'comlink';
import nodeEndpoint from 'comlink/dist/umd/node-adapter';
import { cpus } from 'os';

developit

Module Workers Polyfill

This is a 1.1kb polyfill for Module Workers.

It adds support for new Worker('..',{type:'module'}) to all modern browsers (those that support fetch).

Usage

Copy module-workers-polyfill.js to your web directory, then load it using an import or a script tag. It just needs to be loaded before instantiating your Worker.

sualeh

How to Sign and Release to The Central Repository with GitHub Actions

GitHub allows automated builds using GitHub Actions. A commonly asked question is how to release artifacts (packaged Java jars) built by Maven and Gradle to The Central Repository. The GitHub Actions documentation provides only part of the answer.

So, first, configure your Maven project for staging artifacts to The Central Repository, by reading through Configuring Your Project for Deployment and following those steps. Please make sure that the maven-gpg-plugin is configured to prevent gpg from using PIN entry programs, as follows:

<configuration>
  <gpgArguments>
      <arg>--pinentry-mode</arg>
 loopback

jimit24365

Wifi SSID - Technogise_2.4 (mobile) and Technogise_5 (Laptops) Password is 62697514

PRE-REQUISITES:
Get your laptops with the following INSTALLATIONS done:
• Flutter - https://flutter.dev/docs/get-started/install
• Android Studio - https://developer.android.com/studio/install
• Plugins - https://flutter.dev/docs/get-started/editor

MaterialApp 
https://dartpad.dev/02b1e191976afffb242e15c8da240ffc

luque

Introduction
============

Industry statistics as a whole have failed to improve much since 1968, when software engineering and
scientific management were introduced as means for resolving the "software crisis". Unfortunately
abandoned projects, cost/time overruns, and bloated, buggy software still dominate the landscape.

In spite of the efforts to mitigate this situation --like XP, agile, software craftsmanship or DDD-- the
reality is that a usual software project stack involves an increasingly larger number of programming
languages, DSLs, frameworks, systems, tools, techniques and processes, so it is a fact that the