Skip to main content
SimilarExport ZIP
100%

Gist 593506

✓ Published0🌍 Public
RRestuta
Last edited Sep 23, 2010
Created on Sep 23, 2010

This example demonstrates a Visual Basic script that repeatedly checks for the existence of two PDF files on the filesystem, using a loop with the condition `while not inFSO.FileExists(pdfFileName1) and not inFSO.FileExists(pdfFileName2)`. It shows a polling mechanism where the code pauses execution via the `ExecuteSQL("waitfor DELAY '00:00:02'")` command, which introduces a two-second delay between checks. The visualization tracks the file-state transitions over time, illustrating the wait-and-retry logic. The rendering relies on the base Visual Basic runtime’s file system object (`inFSO`) and SQL delay function, with no external charting libraries.

AI-generated description

Similar vizzes

Loading thumbnail…

Testing the api for multiple files

This example demonstrates a minimalist test of the GitHub Gist API by rendering two JavaScript files, `fileName1.js` and `fileName2.js`, which contain simple console log statements. The visualization displays the raw file contents as retrieved from a Gist, using JavaScript's `console.log` output to show the API's response. The code fetches multiple files from a single Gist endpoint and presents the returned data in a clean, text-based layout, highlighting the API's role in serving static file content.

KKevinGutowski
49% match
Loading thumbnail…

Gist bae6758b4e3645b55f022e6432f29458

This visualization demonstrates the interaction between R and PowerShell, showing how a system call from an R environment triggers a PowerShell script that manipulates data. The code uses the `system2` function to execute a PowerShell command with a specified file path, passing arguments to run `coolScript.ps1`. The example highlights the practical integration of two scripting environments, where R serves as the orchestrator for external process execution. The rendering relies on the command-line interface rather than graphical libraries, focusing on the workflow of invoking and managing external scripts from within an R session. The data flow is implicit in the script's execution, emphasizing interoperability over visual output.

HHugoberry
47% match
Loading thumbnail…

Gist f0e5d88500fd76302d5a1b9ad07b6ae1

This visualization shows a force-directed network graph of file dependencies, where each node represents a file and links connect related components. The layout uses d3.forceSimulation with custom collision and charge forces to position nodes, while link opacity encodes connection strength. The rendering relies on Canvas 2D drawing with getImageData for pixel-level hover detection. The data comes from a static list of file paths, including Microsoft.Mashup.OleDb.1 and Montego.OleDb.1, with edge weights derived from shared prefixes. The code also uses transition.attrTween to animate node positions smoothly when the layout stabilizes.

HHugoberry
45% match
Loading thumbnail…

Gist 47d998760fa7271ac3157ce7d9555612

This example demonstrates how to query and load data from external sources using Power Query's OleDb.Query function, specifically connecting to a local CSV file and an XML catalog. The code shows two approaches: one using Microsoft's ACE OLEDB provider to read a delimited text file, and another using the MSDAOSP provider with MSXML2.DSOControl to access XML data. The visualization highlights the raw query definitions rather than rendering graphical output, focusing on the data-acquisition layer. Both queries reference file paths on the local system, with the CSV query specifying the file directory and the XML query pointing to a catalog file.

HHugoberry
45% match
Loading thumbnail…

Adding a delay between request for computing a Mandelbrot Set calculation and a fetch the results from blob storage

This example demonstrates how to introduce a deliberate ten-second pause between scheduling a Mandelbrot Set calculation and retrieving the result from blob storage. It uses Power Query’s `Function.InvokeAfter` to delay the execution of `MandelbrotBlobFetch`, which asynchronously fetches the computed image from a blob container. The `MandelbrotSchedule` function determines the target folder path, while the delay ensures the computation has finished before the data is pulled. This pattern is useful for coordinating long-running background tasks with subsequent data retrieval in a data-refresh pipeline.

HHugoberry
45% match
Loading thumbnail…

Gist 0bb5514393bdd878235e51ed2fdd3724

This example visualizes the relationships between file names and their associated directory paths using a force-directed graph layout. The code employs `d3.forceSimulation` to position nodes and `d3.forceLink` to draw connecting edges, with each node rendered as a colored circle. The graph is built from a parsed file tree structure, likely derived from object keys or an array of paths, and uses `d3.select` for DOM manipulation. Labels are attached to nodes via SVG text elements, while the simulation updates positions on each tick. The rendering relies on an SVG container, with node colors distinguishing file types from directory paths.

RRainboylvx
44% match
Loading thumbnail…

Gist f90e0dcc12099646652c5dcbc8400a24

This example visualizes the live query log of a Power BI tabular model by monitoring the Analysis Services workspace’s in-memory engine. It shows the most recent command and its start time, appending each new entry to a running history. The code uses the Power Query M language, calling `AnalysisServices.Database` to query the `$SYSTEM.DISCOVER_SESSIONS` DMV and `Folder.Files` to locate the `msmdsrv.port.txt` file that defines the dynamic port. The rendered output is a table combining previous and new log records via `Table.Combine`, with no external charting library involved.

HHugoberry
44% match
Loading thumbnail…

Show hidden files on OSX 10.9

This example visualizes the process of revealing hidden files on OSX 10.9 by executing two shell commands. It shows the terminal commands `defaults write com.apple.finder AppleShowAllFiles TRUE` and `killall Finder` as a sequential code snippet, highlighting the system state change from hidden to visible files. The visualization relies on a simple text-based rendering of the shell script, with no external libraries or APIs beyond standard shell execution. The data source is the literal command sequence itself, presented as a static code block to demonstrate the minimal steps required. The rendering approach is a plain code display, not a chart or graph, focusing on command clarity over graphical abstraction.

CCliffordAnderson
44% match