MilleMiglia generates realistic middle‑mile logistics data

24 09 2026
MilleMiglia generates realistic middle‑mile logistics data

MilleMiglia is a C++ library that produces synthetic middle‑mile logistics networks with up to 10,000 nodes and 100,000 edges. It runs on any POSIX system with a C++17 compiler and requires only standard STL, no external dependencies. The generator outputs JSON‑like files that match the format used by existing VRP solvers, effectively replacing proprietary datasets that are normally inaccessible.

It is useful for researchers and practitioners who need realistic benchmark instances without accessing commercial data. However, it abstracts away real‑world constraints such as traffic variability and carrier contracts, so it may not capture all operational nuances. If you need fine‑grained vehicle scheduling or integration with live routing engines, this tool alone won't suffice.

more: https://research.google/blog/millemiglia-a-realistic-instance-generator-for-middle-mile-logistics/

my other side: ivo.blogspot.com





Knap template engine for Markdown generation

23 09 2026
Knap template engine for Markdown generation

Knap is a template language that converts data into Markdown using variables, filters, and logic. It parses templates into an AST and interprets them without eval or arbitrary JavaScript execution. The library requires Node.js 20 or later for the CLI.

Useful if you need safe templating for data pipelines without sandboxing risks. It lacks a browser build, limiting use to server-side or Node environments. Not for generating HTML or complex front-end logic.

more: https://github.com/obsidianmd/knap

my other side: ivo.blogspot.com





pgbot adds read-only Postgres health checks

22 09 2026
pgbot adds read-only Postgres health checks

This is a single static binary that connects to Postgres using a read-only role and prints a findings-first health report. It calculates cache hits, lock waits, and transaction age locally, writing a baseline file to track changes between runs. The tool runs entirely on your machine without requiring external agents, time-series databases, or write privileges.

It is useful for immediate insight into database performance without deploying new infrastructure. However, the human-readable output is explicitly unstable, so you must parse the versioned JSON contract for any automated scripts. If your workflow relies on the terminal text directly, you will face breaking changes.

more: https://github.com/pgrundev/pgbot

my other side: ivo.blogspot.com





Pinloop CLI Terminal Job Search

22 09 2026
Pinloop CLI Terminal Job Search

Pinloop CLI is a Node‑based command‑line tool (requires Node 22+) that lets you search millions of worldwide job postings from the terminal. It fetches listings hourly from company hiring systems and major boards, stores your resume and preferences locally, and can call an LLM to score each posting against your profile. The tool is installed with a single npm global install and interacts with Pinloop’s servers for search, filtering, and account management.

If you already work with coding agents and prefer staying in the shell, Pinloop can be a convenient alternative to web job boards, though the free tier caps you at five pulls and 150 LLM judgments per month. The reliance on external servers and a paid Pro plan for higher limits means it isn’t a standalone solution for heavy job hunting, and it won’t help if you need a full UI or offline access.

more: https://github.com/pinloop-ai/pinloop-cli

my other side: ivo.blogspot.com





Rune IDE/Tmux Clone – GPU‑Accelerated Native Editor

22 09 2026
Rune IDE/Tmux Clone – GPU‑Accelerated Native Editor

Rune is a native, GPU‑accelerated IDE and terminal multiplexer written in Go. It bundles a terminal multiplexer, an editor, and language intelligence into a single binary for Linux and macOS, using OpenGL or Metal for rendering. The first public release ships with a zero‑dependency installer that pulls a single binary from the internet.

For developers who want a lightweight alternative to Vim or VS Code that can run inside a tmux‑style session, Rune is worth a try. It requires a recent GPU to get the best performance and has no Windows support yet, so teams that need cross‑platform tooling may find it lacking. Also, the plugin ecosystem is still small, so advanced language features may be limited until the community grows.

more: https://github.com/unstablebuild/rune

my other side: ivo.blogspot.com





DeepSeek Balance Whale Widget Plugin

21 09 2026
DeepSeek Balance Whale Widget Plugin

The DeepSeek Balance Whale Widget is a DSH bundle plugin that adds a persistent bubble in the lower‑right corner of the DSH Web interface. It shows the DeepSeek API balance, today's consumption, and per‑round cost, refreshing every 60 seconds and offering full customisation of the bubble content. Installation is a single `dsh plugin` command and it works without any session token. The same repository also provides a separate Codex‑desktop branch that ships as a standalone plugin.

If you already use DSH and want an on‑screen, programmable view of your DeepSeek quota, the widget is a handy addition. The main drawbacks are the two mutually exclusive branches – you must pick either the web or Codex version – and the setup can be fiddly if you need custom API providers. It’s overkill for anyone not embedded in the DSH ecosystem.

more: https://github.com/MeteorNOX/DeepSeek-Balance-Whale-Widget

my other side: ivo.blogspot.com





FuXi: A Static Binary Terminal Coding Agent

21 09 2026
FuXi: A Static Binary Terminal Coding Agent

FuXi is a terminal AI coding agent written in Go that ships as a single static binary with no runtime dependencies. It reads code, edits files, and runs commands from a rich TUI, supporting cost-aware routing across multiple LLM providers.

The code is proprietary, so you cannot audit or modify the engine while the docs and installer are open. You need an account to start, though you can bring your own API keys to avoid managed model transmission.

more: https://github.com/fuxicodex/Fuxi

my other side: ivo.blogspot.com





Java8: Map()+Filter()+Collect() example

25 06 2018
package tool;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
*
* A simple Java Program to demonstrate how to use map and filter method Java 8.
* In this program, we'll convert a list of String into a list of Integer and
* then filter all even numbers.
*/
public class Hello {
   public static void main(String[] args) {
      List<String> numbers = Arrays.asList("1", "2", "3", "4", "5", "6");
      System.out.println("original list: " + numbers);
      List<Integer> even = numbers.stream()
                                        .map(s -> Integer.valueOf(s))
                                        .filter(number -> number % 2 == 0)
                                        .collect(Collectors.toList());
      System.out.println("processed list, only even numbers: " + even);
   }
}

Output
original list: [1, 2, 3, 4, 5, 6]
the processed list, only even numbers: [2, 4, 6]

souce: https://dzone.com/articles/how-to-use-map-filter-collect-of-stream-in-java-8

my other side: ivo.blogspot.com





Functional Design vs Technical Design

7 10 2016

Functional design is the kind of design that is agreed between software architects and business customers. It describes what the system has to do in a way that both parties can understand and agree. It might describe user interface requirements, it might discuss database access, it might discuss web services or other forms of communication, it might discuss service level agreements or clustering and redundancy. The point is that it should be detailled enough to become the agreed definition of what the system will do.

Technical design, on the other hand, is the kind of design that is agreed between software architects and software developers. It describes how the system will be built to meet the functional design. It contains detail and terminology not appropriate to business customers but needed by developers. It might describe screen layouts, it might describe database table and column names, it might discuss WSDL or communication protocols and file formats, it might discuss server and operating system versions and dependencies. The point is that it should be detailled enough to enable unit tests, code, configurations, and technical documentation work to begin.

Frank Carver

Source: https://coderanch.com/t/100106/patterns/Functional-Design-Technical-Design

my other side: ivo.blogspot.com





java; int to int[]

9 09 2016

int[] digits = Integer.toString(num).chars().map(c -> c-='0').toArray();

my other side: ivo.blogspot.com