For example, for the NSString.h header:
clang \
-Xclang \
-ast-dump \
-fsyntax-only \
-x objective-c \
-I/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/Foundation.framework/Headers \
-F/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks \If you want to change things on the root drive of a Mac you will need to take some steps to disable the built in security of the system. Most of these steps are the same regardless if you are on Intel or Apple Silicon. If there is a difference it is noted.
Note that all of these things put a Mac into an unsupported and less secure state.
Make sure you either perform these steps in a VM or that you reset the protections after you are done poking around
(This list is not exahustive on the details of each. Check the links at the end for more info.)
| { config, pkgs, lib, ... }: | |
| let | |
| user = "YOUR_USER"; | |
| password = "YOUR_PASSWORD"; | |
| sshPubKey = "YOUR_PUBLIC_SSH_KEY"; | |
| SSID = "YOUR_WIFI_SSID"; | |
| SSIDpassword = "YOUR_WIFI_PASSWORD"; | |
| hostname = "HOSTNAME_FOR_YOUR_PI"; | |
| k8sApiServerAddr = "https://IP_FOR_YOUR_CONTROL_NODE:6443"; |
The main point is to save the SSL/TLS keys those used by the web browser (SSLKEYLOGFILE=/tmp/tmp-google/.ssl-key.log).
In the example below we run brand new instance of Google Chrome (--user-data-dir=/tmp/tmp-google do the trick):
SSLKEYLOGFILE=/tmp/tmp-google/.ssl-key.log /Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --user-data-dir=/tmp/tmp-google
Then run the Wireshark and open the Preferences -> Protocols -> SSL, where we put the path to the SSL keys log file into the (Pre)-Master-Secret log filename field.
Now all SSL/TLS traffic from this browser instance will be decrypted.
| From: https://blog.lobraun.de/2015/06/06/mount-sd-cards-within-virtualbox-on-mac-os-x/ | |
| Mount SD Cards within VirtualBox on Mac OS X | |
| Sometimes you need to mount your SD cards inside a VirtualBox machine to work with the files on the card. Working with the Raspberry Pi SD card on Mac OS X is an example for this. | |
| My Raspberry Pi runs on Linux with some version of the EXT file system. While there is some support for this on Mac OS X, the available solutions have a lot of limitations, especially when it comes to write support on EXT file systems. As I do not have an USB keyboard, I sometimes need to mount the filesystem on another system to fix a startup problem when some of my experiments go wrong. | |
| VirtualBox in theory allows for passing the internal card reader of the MacBooks to the virtual machine. Unfortunately, this does not work for me (and it seems for many other people). |
| #!/bin/bash | |
| ### steps #### | |
| # Verify the system has a cuda-capable gpu | |
| # Download and install the nvidia cuda toolkit and cudnn | |
| # Setup environmental variables | |
| # Verify the installation | |
| ### | |
| ### to verify your gpu is cuda enable check |
| #!/usr/bin/env bash -e | |
| HOST=${1:-cloudflare.com} | |
| FILENAME=${2:-${HOST%%.*}} | |
| # For file naming, see https://support.ssl.com/Knowledgebase/Article/View/19/0/der-vs-crt-vs-cer-vs-pem-certificates-and-how-to-convert-them | |
| # For HTTP Public Key Pinning (HPKP), see https://developer.mozilla.org/en-US/docs/Web/HTTP/Public_Key_Pinning | |
| CERTIFICATE_PEM="${FILENAME}_certificate.ascii.crt" | |
| CERTIFICATE_DER="${FILENAME}_certificate.crt" | |
| PUBKEY_PEM="${FILENAME}_pubkey.ascii.key" |
Modern Cocoa development involves a lot of asynchronous programming using closures and completion handlers, but these APIs are hard to use. This gets particularly problematic when many asynchronous operations are used, error handling is required, or control flow between asynchronous calls gets complicated. This proposal describes a language extension to make this a lot more natural and less error prone.
This paper introduces a first class Coroutine model to Swift. Functions can opt into to being async, allowing the programmer to compose complex logic involving asynchronous operations, leaving the compiler in charge of producing the necessary closures and state machines to implement that logic.
| struct MinimalDecoder : Decoder { | |
| var codingPath = [CodingKey?]() | |
| var userInfo = [CodingUserInfoKey : Any]() | |
| public func container<Key>(keyedBy type: Key.Type) throws -> KeyedDecodingContainer<Key> { | |
| return KeyedDecodingContainer(MinimalKeyedDecodingContainer<Key>(decoder: self)) | |
| } | |
| public func unkeyedContainer() throws -> UnkeyedDecodingContainer { | |
| return DecodingContainer(decoder: self) |
| #import <Foundation/Foundation.h> | |
| #import <time.h> | |
| #import <os/lock.h> | |
| #define ITERS 2000 | |
| #define NSEC_PER_ITER(time) (((double)time * (double)NSEC_PER_SEC) / (double)ITERS) | |
| #define TEST(body, name) do {\ | |
| start = [NSDate date];\ | |
| for (int i = 0; i < ITERS; i++) {\ |
