Bit Slicer is a universal game trainer for macOS, written using Cocoa and Mach kernel APIs.
It allows you to cheat in video games by searching and modifying values such as your score, lives, ammunition, and much more.
Bit Slicer is a universal game trainer for macOS, written using Cocoa and Mach kernel APIs.
It allows you to cheat in video games by searching and modifying values such as your score, lives, ammunition, and much more.
main
(aka master
) - see below for some benefitgit newpr
and git updatepr
UIDebuggingInformationOverlay
is a private UIWindow
subclass created by Apple, presumably to help developers and designers debug Apple’s own iOS apps.
Harder to get at in iOS 11, but this post shows how to use swizzling to get it working there too.
function isUserInteraction() { const detectionElement = window.document.createElement('audio'); detectionElement.play(); return !detectionElement.paused; }
browsingContextController
property that can be used to make WKWebView
trigger NSURLProtocol
s for HTTP and HTTPS.
A simple macOS tool for briefly hightlighting a small portion of a screen, zooming and centering it on the screen until dismissed. Great for presentations or just quickly checking the pixels on a design.
Inspired by a similar tool shown on a WWDC 2016 video.
SFSafariViewController
, add a view on the edge, and add a UIScreenEdgePanGestureRecognizer
to it.
propTypes
declaration.
Cosmos scans your project for React component fixtures and loads them inside ComponentPlayground, enabling you to:
expr @import Foundation
(or UIKit
or Cocoa
) to get access to Foundation/UIKit/AppKit methods in the Xcode debugger.
jscodeshift is a toolkit for running codemods over multiple JS files.
See also js-codemod, which contains a collection of codemod scripts based on jscodeshift.
<div>
and scroll
events to detect resizing without polling.
NuclearMail is an experiment of writing a webmail client using React and the Flux architecture. It runs completely in the browser and uses the Gmail REST API.
fishhook is a very simple library that enables dynamically rebinding symbols in Mach-O binaries running on iOS in the simulator and on device. This provides functionality that is similar to using DYLD_INTERPOSE
on OS X. At Facebook, we've found it useful as a way to hook calls in libSystem for debugging/tracing purposes (for example, auditing for double-close issues with file descriptors).
A system with prototype implementation for concisely describing and implementing a class of touch interactions.
HeapInspector is an iOS debug tool that monitors the memory heap in your app. You can discover memory leaks, no longer needed living objects and more issues directly on your device without ever starting Instruments.
Immutable data cannot be changed once created, leading to much simpler application development, no defensive copying, and enabling advanced memoization techniques.
Immutable provides List, Stack, Map, OrderedMap, and Set by using persistent hash maps tries and vector tries as popularized by Clojure and Scala. They achieve efficiency on modern JavaScript VMs by using structural sharing and minimizing the need to copy or cache data.
Immutable also provides a lazy Seq, allowing efficient chaining of collection methods like map and filter without creating intermediate representations. Create some Seq with Range and Repeat.
contentEditable
browser inconsistencies that The Guardian ran into while developing their Scribe library.
debug()
, monitor()
, monitorEvents()
and a Chrome extension to extend these to native methods and custom events.
Quickly fills your iPhones Photo Album with thousands of random images from lorempixel.com.
LICEcap can capture an area of your desktop and save it directly to .GIF (for viewing in web browsers, etc) or .LCF (see below).
Sort of related is Sublime Text's hack to animate screenshots.
Library Inspector is a simple tool for inspecting the contents of compiled object code, archives, dynamic libraries (dylib), frameworks and applications. There are two main components, the Library Inspector application, and the Library Inspector Quick Look plugin. The main features provided by Library Inspector include:
dtrace
scripts for tracing Objective-C message sends (with filtering and indentation to make flows easier to follow).
Object graph visualization library, as described in these blog posts:
On Mac OS X graphviz should be installed to get the dot
tool.
Helper tools (fake apps, fake carrier, tap indicator) for recording iOS app screencasts. See this blog post for more details.
WebViewJavascriptBridge (and similar libraries) rely on loading a custom URL scheme in an iframe and intercepting the request in shouldStartLoadWithRequest
. Other approaches include embedded WebSockets and HTTP servers (see LinkedIn.
One alternative to consider is modifying document.cookie
for some magic cookie name value, and then listening for those changes on the iOS side via NSHTTPCookieManagerCookiesChangedNotification
. That might have fewer side-effects that triggering a (sub-)frame load.
Tune-up is a collection of JavaScript utilities that builds upon and improves the UIAutomation library provided by Apple for testing iOS applications via Instruments. While the JavaScript library provided by Apple is fairly complete and robust, it is a bit wordy and repetitive at times. This project aims to reduce as much pain as possible when writing UI tests by enhancing the existing API. It also provides some basic structure for your tests in a manner familiar to most testers.
Summarizes the results of some browser tests done while attempting to implement key stroke handling code in JavaScript. It documents inconsistencies in the way different browsers implement keyboard events.
Apple does code dumps on their open source releases site. For iOS, this contains WebCore
and JavaScriptCore
(because of LGPL), but not WebKit
(BSD).
iOS 6.1 seems to track the open source WebKit repository up to r116247. You can diff Apple's code against the open source repo at that revision to see what is different in iOS.
Plugin that makes it easier to run Xcode without the main toolbar. It adds keyboard shortcuts for selecting the active scheme and device (Ctrl+7 / Ctrl + 8), and a compact popup menu in the window title bar that shows the currently selected run configuration.
FastClick is a simple, easy-to-use library for eliminating the 300ms delay between a physical tap and the firing of a click event on mobile browsers. The aim is to make your application feel less laggy and more responsive while avoiding any interference with your current logic.
See also Google's fast buttons article. Though it may not be necessary anymore, at least on Android (stock browser doesn't do a delay for fixed viewport sites since Gingerbread, and neither does Chrome).
Micro-benchmark comparing doing manual object property traversal and using JSON.stringify
and string comparison of the result. One might think that the JSON approach would be spending more time in native code, thus would be faster, despite the string allocation overhead. But the manual property traversal is always faster (JIT FTW).
So long, for (var i = 0, p; p = a[i]; i++) {...}
. Also related are these tests of Array.prototype.splice()
performance.
Post describing the use of a self-driving screenshot mode for apps (uses WaxSim for a CLI interface to the simulator). See also the original author's take.
UI Screen Shooter is a variant that uses UI Automation.
On the desktop, the screencapture
tool may be useful.
./configure
and make
.zlib
and is a sibling of of the pngcheck
directory.pngcheck
with make -f Makefile.unx
.pngcheck
somewhere in your path.pngdiff
shell script somewhere in your path:
#!/bin/bash LOCAL_FILE=`mktemp /tmp/pngdiff.local.XXXXXX` || exit 1 pngcheck -v $1 > $LOCAL_FILE REMOTE_FILE=`mktemp /tmp/pngdiff.remote.XXXXXX` || exit 1 pngcheck -v $2 > $REMOTE_FILE bbdiff --wait --resume $LOCAL_FILE $REMOTE_FILE(replacing
bbdiff
with your preferred text diffing tool)~/.gitconfig
:
[difftool "pngdiff"] cmd = pngdiff "$REMOTE" "$LOCAL"
git difftool -t pngdiff
to view diffs.Relatedly, to view diffs of images in Preview.app
(using the up/down arrows to toggle between the old and new versions), add this to ~/.gitconfig
:
[difftool "imagediff"] cmd = open -n -W -a preview "$REMOTE" "$LOCAL"
Pants makes the manipulation and distribution of hermetically sealed Python environments painless.
iOS Objective-C headers as derived from runtime introspection. Generated using RuntimeBrowser.
ssh-copy-id
installs your public key in a remote machine's authorized_keys
. It should be in the contrib
of the OpenSSH repository. There are other mirrors.
Background and details on the implementation of hardware-accelerated compositing in Chrome.
Links:
Recipe:
svn ls --username mihaip@chromium.org svn://svn.chromium.org/chrome/trunk/src
and svn ls --username mihaip@chromium.org svn://svn.chromium.org/blink/trunk
to verify said credentials.cd ~/Developer/tools/
svn co http://src.chromium.org/chrome/trunk/tools/depot_tools
cd ../source
mkdir chromium
~/Developer/source/chromium
to the list of paths that Spotlight excludescd chromium
fetch blink
cd src
rm -rf out/Debug
export GYP_GENERATORS="ninja"
export GYP_DEFINES="component=shared_library disable_nacl=1"
./build/gyp_chromium
ninja -C out/Debug chrome
Updating:
cd ~/Developer/source/chromium/src
git pull --rebase origin master
export GYP_GENERATORS="ninja"
export GYP_DEFINES="component=shared_library disable_nacl=1"
gclient sync
ninja -C out/Debug chrome
Reload Reader or mark an item as read (so that the command token gets refreshed) and then run the following in the DevTools console:
var xhr = new XMLHttpRequest(); xhr.onload = function() { console.log(xhr.status); }; xhr.onerror = function() { console.log('error'); }; var params = ''; function addParam(name, value) { if (params) { params += '&'; } params += encodeURIComponent(name) + '=' + encodeURIComponent(value); } addParam('T', _COMMAND_TOKEN); addParam('k', 'item-actions'); addParam('v', '{"plusone-action": false, "share-action": true, "email-action": true, "tags-action": true}'); xhr.open('POST', '/reader/api/0/preference/set'); xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded'); xhr.send(params);
Once you see 200
printed, you can reload Reader, and the +1 buttons should be gone.
To reset things back to the way they were, change the 'v'
value to '{}'
.
Deploying is a big part of the lives of most GitHub employees. We don't have a release manager and there are no set weekly deploys. Developers and designers are responsible for shipping new stuff themselves as soon as it's ready. This means that deploying needs to be as smooth and safe a process as possible.
The best system we've found so far to provide this flexibility is to have people deploy branches. Changes never get merged to master until they have been verified to work in production from a branch. This means that master is always stable; a safe point that we can roll back to if there's a problem.
Tumblr for iOS: Uses a JSON API and Mustache templates like a mobile site would, but does template evaluation on the native side, with the UIWebView just being used to render the resulting HTML. This makes the absence of a JIT less critical.
LinkedIn: Works around the lack of a good web/native bridge by embedding an extremely lightweight HTTP server in the application itself. The HTTP server exposes native functionality through a very simple REST API that can be consumed in the embedded HTML controls through standard JavaScript HTTP requests.
See also this SXSW panel.
Update on 12/7/2012: Tumblr appears to have changed to being purely native.
iPhone app that automatically keeps track of your commute and helps you detect patterns. Using geo-fencing, it could keep track of when you leave your designed home/work spots, and then do a continuous GPS track along the way. Once data is gathered, it could be visualized (e.g. by day of week, or by departure time), displayed on a map to show alternate route rates (e.g. Grant Road vs. 85) and with enough smarts, turned into a (local) push notification that tells you which way to go today.
Commute Tracker gets pretty close to this (it's automatic), but it's buggy (I had a 1 second commute), tracks too much (I want to exclude days where I make a grocery store detour) and is on the ugly side. Daily Commute is prettier, but it's too manual, requiring commutes to be started and stopped.
Build a Stream Spigot tool for filtering of feeds. Unlike Feed Rinse or Yahoo! Pipes, it wouldn't involve taking a feed URL, giving it to the tool, and getting a filtered URL to subscribe to in return. Instead, it would work by connecting to your Google Reader account and then marking matching items as read, so that they don't show up (if using new items only view).
This would have the advantage of not having to re-subscribe when deciding to filter something, benefiting from the regular crawl speed (vs. filtered feed URLs generally having only one subscriber and thus being in the slow crawl bucket) and having item metadata be preserved (though that matters less now that likes and shares are gone).
The filtering could either be done periodically, or for feeds that are PubSubHubbub-enabled, it could be triggered by PSHB pings. It does mean that there is a window during which items that should be filtered our are visible, but the filtering is likely to be cheap enough (get items since the last check, apply a read tag) that it can be done quite frequently.
In addition to the read tag, a "filtered" state tag should also be applied to the items, so that these items can be differentiated during subsequent API calls.
To make the Chrome Apps edit-reload cycle faster (especially when there's a build/compilation step), a helper extension could be written. It could reload the app using the management API. More importantly, it could have a custom hook to trigger the re-build/compile step before reloading the app. This could be as simple as an HTTP request to a local server, or something fancier with native messaging once that's available. This could all be triggered via a keyboard command using the commands API.
Chrome Extension Reloader Macro is something along these lines, albeit targeted at extension developers. LiveReload could also be extended to support this use case.
Turn Source Quicklinks into a packaged app. It can use <browser>
to embed the Chromium code search and have a custom toolbar that allows switching to SVN history, blame, etc. It can also log recently pulled up docs in a sidebar, support looking up files by name.
The Square card reader converts the magnetic stripe on a credit card to audio. Using the getUserMedia()
API from WebRTC, it should be possible to get at that audio data (via WebAudio). mslib is a library for decoding this magnetic stripe data (blog posts with more details). It could be incorporate via NaCl. Rhombus is another project that does this (albeit Java-based).
One possible application is in a Chrome extension that implements payment form filling out by swiping a card.
What are some time-saving tips that every Linux user should know?
Remote terminal application that allows roaming, supports intermittent connectivity, and provides intelligent local echo and line editing of user keystrokes.
Mosh is a replacement for SSH. It's more robust and responsive, especially over Wi-Fi, cellular, and long-distance links.
iPhone app that lets you put nearby Macs to sleep (discovery can be handled via Bonjour). Unlike iShutdown or Control!, it shouldn't require installing a special daemon on the Mac that's to be controlled. iSleep claims to do this via Remote Login (i.e. ssh), but the reviews seem mixed. If remote Apple events are still possible, then it should be feasible via that. If not (or as an alternative), whatever mechanism Apple Remote Desktop uses could be used here too.
apt-file can find which packages include a specific file. Ubuntu Packages Search also provides a web UI.
In the vein of the Firefox extension Dormancy, build a Chrome extension that frees up resources used by background tabs that haven't been accessed in a while. Using the chrome.tabs.onUpdated
event, an LRU list could be maintained. Inactive tabs would have a screenshot taken via chrome.tabs.captureVisibleTab
, and the tab would then be navigated to a chrome-extension://
URL that shows that screenshot (thus making all inactive tabs live in the extension's process, instead of separate renderer ones). When the tab is re-selected, history.back()
could be used to back to the live page (by using history traversal, form/scroll position restore is invoked, retaining as much of the state as possible).
Optionally, there could be a browser action that displays the total/live/frozen tab count, in the same way that Tab Count does.
Rietveld (and presumably other code review tools) inline diffs in emails. Even if they don't, they generally have a URL that points at the review. A Gmail gadget could be written that inlines the diffs (if not already inline), and pretty-prints them (with syntax highlighting).
GitHubDiff does something like this for GitHub emails.
TodoMVC is a project which offers the same Todo application implemented using MV* concepts in most of the popular JavaScript MV* frameworks of today.
Solutions look and feel the same, have a common simple feature-set and make it easy for you to compare the syntax and structure of different frameworks so you can select the one you feel the most comfortable with.
Google has shut down Code Search and the Social Graph API. Replicating those services outside of Google is hard; they presuppose a scalable, well-oiled crawling/indexing/serving machine. Only Google has been able to release interesting n-gram data (from books too).
Along the same lines, the HTTP Archive tracks 55K URLs (with a goal of 1M by the end of 2012). W3Techs also only looks at the Alexa top 1 million. Presumably this is because crawling is hard. If Foursquare wanted to know how many pages have a link to a foursquare.com URL, would they want to crawl the whole web?
"Aleph" would be an infrastructure company that offers a few services:
For the web index to be useful for some applications, it would need to have a PageRank-like attribute per page to expose importance (and/or a number of visits/traffic).
In theory the Internet Archive has a lot of this data. They make their data available "at no cost to researchers, historians, and scholars," thus their willingness to license is unclear.
As for the name, the Aleph was a MacGuffin-like device from Mona Lisa Overdrive that a large copy of the Internet stored.
Update on 5/7/2012: Blekko appears to offer basic grepping functionality.
Update on 2/24/2013: CommonCrawl is a non-profit with 6 billion pages indexed and available for MapReduce.
A Locker is a container for personal data, which gives the owner the ability to control how it's protected and shared. It retrieves and consolidates data from multiple sources, to create a single collection of the things you see and do online: the photos you take, the places you visit, the links you share, contact details for the people you communicate with, and much more. It also provides flexible APIs for developers to build rich applications with access to all of this information.
The Locker Project is an open source development effort, permissively licensed, and sponsored by Singly. Singly provides a personal data service based on this technology, and also welcomes its use by anyone for any purpose.
CodeRunner: Edit and run code in any programming language with just a single click. Write and test code, run scripts, work with algorithms, or simply experiment with a new coding or scripting language.
Patterns: A simple yet powerful tool for working with regular expressions. Build great patterns quickly and effortlessly with syntax coloring and with matching and replacing occurring in real time.
PhantomJS provides a headless, yet fully-featured, WebKit browser that can easily be launched off the command-line, and then scripted and manipulated with JavaScript.
confess.js is a small library that uses PhantonJS to make it easy to analyze web pages and apps for various purposes.
ProtoRPC makes it easy to write consistent, reliable web interfaces that can be used, for example, to do the following:
mtr combines the functionality of the 'traceroute' and 'ping' programs in a single network diagnostic tool.
As mtr starts, it investigates the network connection between the host mtr runs on and a user-specified destination host. After it determines the address of each network hop between the machines, it sends a sequence ICMP ECHO requests to each one to determine the quality of the link to each machine. As it does this, it prints running statistics about each machine.
In a conventional single-exposure photograph, moving objects or moving cameras cause motion blur. The exposure time defines a temporal box filter that smears the moving object across the image by convolution. This box filter destroys important high-frequency spatial details so that deblurring via deconvolution becomes an ill-posed problem.
Rather than leaving the shutter open for the entire exposure duration, we "flutter'' the camera's shutter open and closed during the chosen exposure time with a binary pseudo-random sequence. The flutter changes the box filter to a broad-band filter that preserves high-frequency spatial details in the blurred image and the corresponding deconvolution becomes a well-posed problem. We demonstrate that manually-specified point spread functions are sufficient for several challenging cases of motion-blur removal including extremely large motions, textured backgrounds and partial occluders.
.gitconfig
:
[diff] tool = "bbdiff" [difftool] prompt = false [difftool "bbdiff"] cmd = /home/mihaip/bin/bbdiff "$REMOTE" "$LOCAL"
bbdiff
on the remote machine with the following contents:
#!/bin/sh source_machine=${SSH_CLIENT%% *} for arg in "$@" do readlink -fn $arg if [[ $arg == /tmp/* ]] then scp $arg mihaip@$source_machine:$arg fi echo -n " " done | xargs ssh mihaip@$source_machine /usr/local/bin/bbdiff --wait --resume
Same set of utilities used to build and run internal Python apps at Google:
xStats provides simple charts to help monitor your code performance.
get_source_machine
sshfs mihaip@snowberry.local:/D \ /D \ -oauto_cache,reconnect,volname=snowberry-mihaip
.bashrc
:
bbedit() { source_machine=$(get_source_machine) for arg in "$@" do readlink -fn $arg echo -n " " done | xargs ssh mihaip@$source_machine /usr/local/bin/bbedit }
.bashrc
:
get_source_machine() { echo ${SSH_CLIENT%% *} } function growlnotify() { if [ "$AT_HOME" = "true" ]; then return; fi source_machine=$(get_source_machine) ssh mihaip@$source_machine /usr/local/bin/growlnotify \ -n "command-notifier" \ -m \"[$PWD]\" \"$1\" 2> /dev/null }
command-notifier
"Application." (I like Music Video)/System/Library/Java/JavaVirtualMachines/1.6.0.3.jdk
and pointing Eclipse at it worked for me.
Underscore is a utility-belt library for JavaScript that provides a lot of the functional programming support that you would expect in Prototype.js (or Ruby), but without extending any of the built-in JavaScript objects. It's the tie to go along with jQuery's tux.
Underscore provides 60-odd functions that support both the usual functional suspects: map
, select
, invoke
— as well as more specialized helpers: function binding, javascript templating, deep equality testing, and so on. It delegates to built-in functions, if present, so modern browsers will use the native implementations of forEach
, map
, reduce
, filter
, every
, some
and indexOf
.
CoffeeScript is a little language that compiles into JavaScript. Underneath all of those embarrassing braces and semicolons, JavaScript has always had a gorgeous object model at its heart. CoffeeScript is an attempt to expose the good parts of JavaScript in a simple way.
The golden rule of CoffeeScript is: 'It's just JavaScript'. The code compiles one-to-one into the equivalent JS, and there is no interpretation at runtime. You can use any existing JavaScript library seamlessly (and vice-versa). The compiled output is readable and pretty-printed, passes through JavaScript Lint without warnings, will work in every JavaScript implementation, and tends to run as fast or faster than the equivalent handwritten JavaScript.
The boilerpipe library provides algorithms to detect and remove the surplus 'clutter' (boilerplate, templates) around the main textual content of a web page.
Instance/web API running at http://boilerpipe-web.appspot.com/.
Graphite is a highly scalable real-time graphing system. As a user, you write an application that collects numeric time-series data that you are interested in graphing, and send it to Graphite's processing backend, carbon, which stores the data in Graphite's specialized database. The data can then be visualized through Graphite's web interfaces.
Used by Etsy.
Etsy also has StatsD (blog post) which is a daemon that increments/times can be sent to, which aggregates them and sends them to Graphite."ack is a tool like grep, designed for programmers with large trees of heterogeneous source code."
Convert input text to various representations and escaping levels.
Also related: Text Escaping and Unescaping in JavaScript.
Knockout is a JavaScript library that makes it easier to create rich, desktop-like user interfaces with JavaScript and HTML, using observers to make your UI automatically stay in sync with an underlying data model. It works particularly well with the MVVM pattern, offering declarative bindings somewhat like Silverlight but without the browser plugin.
querySelectorAll
on all the selectors in loaded stylesheets and then sorts their eval time.
For when I want to actually learn a DVCS:
Mercurial is a modern, open source, distributed version control system, and a compelling upgrade from older systems like Subversion. In this user-friendly, six-part tutorial, Joel Spolsky teaches you the key concepts.
Add-on appears to be stuck at Firefox 3.5-only though.
Labs/Memory Profiler - MozillaWiki: "Memory Profiler is an experimental Labs project that attempts to make debugging memory use in web pages easier.
For more information about the tool's design and rationale, see Atul's blog post entitled Web Application Memory Profiling, Take Two."